# Race Conditions

Las condiciones de carrera son un tipo común de vulnerabilidad estrechamente relacionada con los defectos de la lógica empresarial. Se producen cuando los sitios web procesan las solicitudes simultáneamente sin las salvaguardias adecuadas. Esto puede llevar a múltiples hilos distintos interactuando con los mismos datos al mismo tiempo, resultando en una "colisión" que causa un comportamiento no intencionado en la aplicación. Un ataque con condición de carrera utiliza peticiones cuidadosamente cronometradas para causar colisiones intencionales y explotar este comportamiento no deseado con fines maliciosos.

<figure><img src="https://2827710683-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FV9yg1NBoB0HDHj681gSk%2Fuploads%2FqyeKkF4ylHmJoTLBQ1uP%2Fimagen.png?alt=media&#x26;token=4c3cc2d1-0b09-4e51-b488-1b47907ca674" alt=""><figcaption></figcaption></figure>

El período de tiempo durante el cual es posible una colisión se conoce como la "ventana de la carrera". Esta podría ser la fracción de un segundo entre dos interacciones con la base de datos, por ejemplo.

Al igual que otros defectos lógicos, el impacto de una condición de carrera depende en gran medida de la aplicación y la funcionalidad específica en la que se produce.

En esta sección, aprenderás cómo identificar y explotar diferentes tipos de condiciones de carrera. Te enseñaremos cómo la herramienta incorporada de Burp Suite puede ayudarte a superar los desafíos de realizar ataques clásicos, además de una metodología probada que te permita detectar nuevas clases de condiciones de carrera en procesos ocultos de varios pasos. Estos van mucho más allá del límite por los sobrecostos que usted puede estar familiarizado ya.

### Limitación de las condiciones de carrera

El tipo de condición de carrera más conocido le permite superar algún tipo de límite impuesto por la lógica de negocio de la aplicación.

Por ejemplo, considere una tienda en línea que le permita introducir un código promocional durante el checkout para obtener un descuento de una sola vez en su pedido. Para aplicar este descuento, la solicitud podrá realizar los siguientes pasos de alto nivel:

1. Comítelo que no ha usado este código.
2. Aplicar el descuento al total del pedido.
3. Actualice el registro en la base de datos para reflejar el hecho de que ahora ha utilizado este código.

Si más tarde intentas reutilizar este código, las comprobaciones iniciales realizadas al inicio del proceso deberían impedirte hacer esto:

<figure><img src="https://2827710683-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FV9yg1NBoB0HDHj681gSk%2Fuploads%2FnPrTgyCsfb4j0AnCYgv5%2Fimagen.png?alt=media&#x26;token=bbf3bae3-a57d-4732-b38e-611f4a8d5d5a" alt=""><figcaption></figcaption></figure>

Ahora considere lo que pasaría si un usuario que nunca haya aplicado este código de descuento antes de intentar aplicarlo dos veces casi exactamente al mismo tiempo:

<figure><img src="https://2827710683-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FV9yg1NBoB0HDHj681gSk%2Fuploads%2FpOK3MNVJpLUjfvjT4XRi%2Fimagen.png?alt=media&#x26;token=91b0f6df-0e3c-41ba-b813-fc60e2025b37" alt=""><figcaption></figcaption></figure>

Como puedes ver, la aplicación pasa a través de un sub-estado temporal; es decir, un estado en el que entra y luego sale de nuevo antes de que el procesamiento de solicitudes esté completo. En este caso, el sub-estado comienza cuando el servidor comienza a procesar la primera solicitud, y termina cuando actualiza la base de datos para indicar que ya ha utilizado este código. Esto introduce una pequeña ventana de carrera durante la cual puedes reclamar repetidamente el descuento tantas veces como quieras.

Hay muchas variaciones de este tipo de ataque, incluyendo:

* Redeeming a gift card multiple times
* Rating a product multiple times
* Withdrawing or transferring cash in excess of your account balance
* Reusing a single CAPTCHA solution
* Bypassing an anti-brute-force rate limit

Los límites son un subtipo de las llamadas fallas de "tiempo de control al tiempo de uso" (TOCTOU). Más tarde en este tema, veremos algunos ejemplos de vulnerabilidades de condiciones de carrera que no caen en ninguna de estas categorías.

#### Detectar y explotar condiciones de carreras de sobrecostos con Burp Repeater

El proceso de detección y explotación de las condiciones de carreras de sobrecostos es relativamente sencillo. En términos de alto nivel, todo lo que necesitas hacer es:

1. Identificar una variable de un solo uso o límite de tarifa que tenga algún tipo de impacto de seguridad u otro propósito útil.
2. Emite múltiples solicitudes a este endpoint en rápida sucesión para ver si puedes sobrepasar este límite.

El principal reto es la sincronización de las peticiones para que al menos dos ventanas de carreras se alineen, causando una colisión. Esta ventana a menudo es de sólo milisegundos y puede ser aún más corta.

Incluso si usted envía todas las solicitudes exactamente al mismo tiempo, en la práctica hay varios factores externos incontrolables e impredecibles que afectan cuando el servidor procesa cada solicitud y en qué orden.

<figure><img src="https://2827710683-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FV9yg1NBoB0HDHj681gSk%2Fuploads%2FUzHtULdL6M3zF3Yi6MNy%2Fimagen.png?alt=media&#x26;token=eba03876-cc88-4d93-863f-5e9774041707" alt=""><figcaption></figcaption></figure>

[Burp Suite 2023.9](https://portswigger.net/burp/releases#professional) añade nuevas capacidades poderosas a Burp Repeater que le permiten enviar fácilmente un grupo de solicitudes paralelas de una manera que reduce en gran medida el impacto de uno de estos factores, a saber, el nervio de red. Burp ajusta automáticamente la técnica que utiliza para adaptarse a la versión HTTP compatible con el servidor:

* Para HTTP/1, utiliza la clásica técnica de sincronización de último byte.
* Para HTTP/2, utiliza la técnica de ataque de un solo paquete, demostrada por PortSwigger Research en Black Hat USA 2023.

El ataque de un solo paquete le permite neutralizar completamente la interferencia del nervios de la red mediante el uso de un solo paquete TCP para completar 20-30 solicitudes simultáneamente.

<figure><img src="https://2827710683-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FV9yg1NBoB0HDHj681gSk%2Fuploads%2F9rJAsHynbcyzxSsRzBnb%2Fimagen.png?alt=media&#x26;token=6b2cc01c-048d-4f94-8ad8-c993706a8a00" alt=""><figcaption></figcaption></figure>

Aunque a menudo se pueden utilizar sólo dos solicitudes para desencadenar un exploit, enviar un gran número de solicitudes como esta ayuda a mitigar la latencia interna, también conocida como nervios de la parte del servidor. Esto es especialmente útil durante la fase inicial de descubrimiento. Cubriremos esta metodología con más detalle.

### Sending requests in parallel -Repeater para las Race Conditions

If you select **Send group in parallel**, Repeater sends the requests from all of the group's tabs at once. This is useful as a way to identify and exploit race conditions.

#### More information

For more information on testing for race conditions, see the [Race conditions](https://portswigger.net/web-security/race-conditions) Web Security Academy topic.

Repeater synchronizes parallel requests to ensure that they all arrive in full at the same time. It uses different synchronization techniques depending on the HTTP version used:

* When sending over HTTP/1, Repeater uses last-byte synchronization. This is where multiple requests are sent over concurrent connections, but the last byte of each request in the group is withheld. After a short delay, these last bytes are sent down each connection simultaneously.
* When sending over HTTP/2+, Repeater sends the group using a single packet attack. This is where multiple requests are sent via a single TCP packet.

When you select a tab containing a response to a parallel request, an indicator in the bottom-right corner displays the order in which that response was received within the group (for example, 1/3, 2/3).

### Soluciones para las race conditions en golang →

Según mi aprendizaje y lo que he estudiado por ejm con golang podemos implementar las waitgroups en conjunción con los mutexes para llevar a cabo la solución de este problema:

{% content-ref url="race-conditions/mutexes-golang" %}
[mutexes-golang](https://juanfelipeoz.gitbook.io/notes/portswigger-webacademy/server-side-topics/race-conditions/mutexes-golang)
{% endcontent-ref %}

{% content-ref url="race-conditions/laboratorio-limit-overrun-race-conditions" %}
[laboratorio-limit-overrun-race-conditions](https://juanfelipeoz.gitbook.io/notes/portswigger-webacademy/server-side-topics/race-conditions/laboratorio-limit-overrun-race-conditions)
{% endcontent-ref %}

***

#### Detectar y explotar condiciones de carreras de sobrecosto con Turbo Intruder

Además de proporcionar soporte nativo para el ataque de un solo paquete en Burp Repeater, también hemos mejorado la extensión de Turbo Intruder para apoyar esta técnica. Puede descargar la última versión de la [tienda BApp](https://portswigger.net/bappstore/9abaa233088242e8be252cd4ff534988).

Turbo Intruder requiere cierta competencia en Python, pero se adapta a ataques más complejos, como aquellos que requieren múltiples reinicias, tiempo de solicitud escameteado o un número extremadamente grande de solicitudes.

Para usar el ataque de un solo paquete en Turbo Intruder:

1. Asegúrese de que el objetivo soporta HTTP/2. El ataque de un solo paquete es incompatible con HTTP/1.
2. Fisean el `engine=Engine.BURP2`y `concurrentConnections=1`opciones de configuración para el motor de solicitud.
3. Al hacer cola de sus solicitudes, agruéllas asignándolas a una puerta llamada usando el `gate`argumento para la `engine.queue()`método.
4. Para enviar todas las solicitudes en un grupo dado, abra la puerta respectiva con la `engine.openGate()`método.

```python
def queueRequests(target, wordlists):
    engine = RequestEngine(endpoint=target.endpoint,
                            concurrentConnections=1,
                            engine=Engine.BURP2
                            )

    # queue 20 requests in gate '1'
    for i in range(20):
        engine.queue(target.req, gate='1')

    # send all requests in gate '1' in parallel
    engine.openGate('1')
```

Para más detalles, vea la `race-single-packet-attack.py` template proporcionada en el directorio de ejemplos por defecto de Turbo Intruder.

{% content-ref url="race-conditions/laboratorio-bypassing-rate-limits-via-race-conditions" %}
[laboratorio-bypassing-rate-limits-via-race-conditions](https://juanfelipeoz.gitbook.io/notes/portswigger-webacademy/server-side-topics/race-conditions/laboratorio-bypassing-rate-limits-via-race-conditions)
{% endcontent-ref %}

***

### Secuencias de varios pasos escondidas

En la práctica, una sola solicitud puede iniciar una secuencia completa de varios pasos entre bastidores, la transición de la aplicación a través de múltiples estados ocultos que entra y luego sale de nuevo antes de que se complete el procesamiento de solicitudes. Nos referiremos a estos como "sub-estados".

Si puede identificar una o más solicitudes de HTTP que causan una interacción con los mismos datos, puede potencialmente abusar de estos sub-estado para exponer variaciones sensibles al tiempo de los tipos de defectos lógicos que son comunes en los flujos de trabajo de varios pasos. Esto permite explotar la condición de la carrera que van mucho más allá de los sobrecostos límite.

Por ejemplo, usted puede estar familiarizado con los flujos de trabajo defectos de autenticación multifactor (MFA) que le permiten realizar la primera parte del inicio de sesión utilizando credenciales conocidas, luego navegar directamente a la aplicación a través de la navegación forzada, evitando efectivamente MFA por completo.

#### Nota

Si no está familiarizado con este exploit, echa un alta laboratorio de bypass 2FA en nuestro tema de vulnerabilidades de autententicación.

El siguiente pseudocódigo demuestra cómo un sitio web podría ser vulnerable a una variación de raza de este ataque:

```

    session['userid'] = user.userid
    if user.mfa_enabled:
    session['enforce_mfa'] = True
    # generate and send MFA code to user
    # redirect browser to MFA code entry form

```

Como puedes ver, esta es de hecho una secuencia de varios pasos dentro del lapso de una sola solicitud. Lo más importante es que pasa a través de un sub-estado en el que el usuario tiene temporalmente una sesión válida, pero MFA aún no se está aplicando. Un atacante podría potencialmente explotar esto enviando una solicitud de inicio de sesión junto con una solicitud a un endpoint sensible y autenticado.

Iremos algunos ejemplos más de secuencias ocultas de varios pasos más tarde, y usted será capaz de practicar explotándolos en nuestros laboratorios interactivos. Sin embargo, dado que estas vulnerabilidades son bastante específicas de la aplicación, es importante primero entender la metodología más amplia que necesitarás aplicar para identificarlas eficientemente, tanto en los laboratorios como en la naturaleza.

### Metodología

Para detectar y explotar secuencias ocultas en varios pasos, recomendamos la siguiente metodología, que se resume en el papel blanco [Destrozando la máquina de estado: El verdadero potencial de las condiciones de carrera web](https://portswigger.net/research/smashing-the-state-machine) de PortSwigger Research.

<figure><img src="https://2827710683-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FV9yg1NBoB0HDHj681gSk%2Fuploads%2FKx7jSJ2AZvwOiv5HX16Z%2Fimagen.png?alt=media&#x26;token=2c5078b8-d725-4993-9170-801d0f2ec414" alt=""><figcaption></figcaption></figure>

#### 1 - Predict potenciales colisiones

Probando cada endpoint es poco práctico. Después de mapear el sitio de destino como es normal, puede reducir el número de puntos de end que necesita probar haciéndole las siguientes preguntas:

* **Es esto crítico la seguridad de endpoint?** Muchas variables no tocan la funcionalidad crítica, por lo que no vale la pena probarlas.
* **Hay algún potencial de colisión?** Para una colisión exitosa, normalmente necesitas dos o más solicitudes que desencadenen operaciones en el mismo registro. Por ejemplo, considere las siguientes variaciones de una implementación de restablecimiento de contraseña:

<figure><img src="https://2827710683-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FV9yg1NBoB0HDHj681gSk%2Fuploads%2FU4Xwq6PQk9X871eqrNsg%2Fimagen.png?alt=media&#x26;token=14f5b418-a6de-4b36-a1d7-8ad2e85434f4" alt=""><figcaption></figcaption></figure>

Con el primer ejemplo, es poco probable que la solicitud de reinicias de contraseña paralelas para dos usuarios diferentes cause una colisión, ya que resulta en cambios en dos registros diferentes. Sin embargo, la segunda implementación le permite editar el mismo registro con solicitudes para dos usuarios diferentes.

#### 2 - Probe para pistas

Para reconocer pistas, primero necesita comparar cómo se comporta el endpoint en condiciones normales. Puede hacerlo en Burp Repeater agrupando todas sus solicitudes y usando el **grupo Send en la opción secuencia (conexiones separadas).** Para más información, consulte [Enviar solicitudes en secuencia](https://portswigger.net/burp/documentation/desktop/tools/repeater/send-group#sending-requests-in-sequence).

A continuación, envíe el mismo grupo de solicitudes a la vez utilizando el ataque de un solo pócket (o sincronización de último byte si HTTP/2 no es compatible) para minimizar el nervio de la red. Puede hacerlo en Burp Repeater seleccionando el **grupo Enviar en** paralelo. Para obtener más información, consulte [Enviar solicitudes en paralelo](https://portswigger.net/burp/documentation/desktop/tools/repeater/send-group#sending-requests-in-parallel). Alternativamente, puede utilizar la extensión Turbo Intruder, que está disponible en la [tienda BApp](https://portswigger.net/bappstore/9abaa233088242e8be252cd4ff534988).

Cualquier cosa puede ser una pista. Sólo busque alguna forma de desviación de lo que observó durante el benchmarking. Esto incluye un cambio en una o más respuestas, pero no olvide efectos de segundo orden como diferentes contenidos de correo electrónico o un cambio visible en el comportamiento de la aplicación después.

#### 3 - Prove el concepto

Trate de entender lo que está sucediendo, eliminar las solicitudes superfluas y asegúrese de que todavía puede replicar los efectos. Las condiciones avanzadas de la carrera pueden causar primitivos inusuales y únicos, por lo que el camino al máximo impacto no siempre es inmediatamente obvio. Puede ayudar pensar en cada condición de carrera como una debilidad estructural en lugar de una vulnerabilidad aislada.

### Condiciones de carrera multi-punto

Tal vez la forma más intuitiva de estas condiciones raciales son aquellas que implican enviar solicitudes a múltiples puntos finales al mismo tiempo.

Piensa en el fallo de lógica clásico en las tiendas online donde añades un artículo a tu cesta o carrito, paga por ello, luego añade más artículos al carro antes de la cesta antes de la cesta de la fuerza a la página de confirmación del pedido.

#### Nota

Si no está familiarizado con este exploit, echa un registro de validación de flujo de trabajo Insuficiente de nuestro tema de vulnerabilidades de lógica de negocio.

Una variación de esta vulnerabilidad puede ocurrir cuando se realiza la validación del pago y la confirmación del pedido durante el procesamiento de una sola solicitud. La máquina estatal para el estado del pedido podría verse algo como esto:

<figure><img src="https://2827710683-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FV9yg1NBoB0HDHj681gSk%2Fuploads%2F7F5u1nDcLI5UVS3B6NCw%2Fimagen.png?alt=media&#x26;token=092940ee-6f2a-4c85-8504-d5f52e089b9b" alt=""><figcaption></figcaption></figure>

En este caso, puedes añadir más elementos a tu cesta durante la ventana de la carrera entre cuando se valida el pago y cuando el pedido se confirma finalmente.

#### Alineando ventanas de carrera multi-punto

Cuando se hace una prueba para las condiciones de carrera multi-punto, puede encontrar problemas tratando de alinear las ventanas de la carrera para cada solicitud, incluso si los envía a todos exactamente al mismo tiempo utilizando la técnica de un solo paquete.

<figure><img src="https://2827710683-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FV9yg1NBoB0HDHj681gSk%2Fuploads%2FMi3VGAr3SIk7vG7oc0tG%2Fimagen.png?alt=media&#x26;token=21e7ce96-8fc0-4e23-ae36-fc1d8b8570c0" alt=""><figcaption></figcaption></figure>

Este problema común es causado principalmente por los dos factores siguientes:

* **Retraso introducido por la arquitectura** de **la red -** Por ejemplo, puede haber un retraso cuando el servidor frontal establece una nueva conexión con el back-end. El protocolo utilizado también puede tener un gran impacto.
* **Retrasados introducidos por procesamiento específico de la variable -** Diferentes variables varían inherentemente en sus tiempos de procesamiento, a veces significativamente, dependiendo de las operaciones que desencadenen.

Afortunadamente, hay posibles soluciones a ambos temas.

### Calentamiento de la conexión

Los retrasos en la conexión trasero no suelen interferir con los ataques de condiciones de carrera porque normalmente retrasan las solicitudes paralelas por igual, por lo que las solicitudes permanecen en sincronía.

Es esencial poder distinguir estos retrasos de los causados por factores específicos de la variable. Una forma de hacerlo es "calentamiento" de la conexión con una o más solicitudes intrasecuentes para ver si esto suaviza los tiempos de procesamiento restantes. En Burp Repeater, puedes intentar añadir un `GET`solicitud para la página de inicio del grupo de pestañas, luego usando el **grupo Enviar en la** opción **secuencia (conexión única).**

Si la primera solicitud todavía tiene un tiempo de procesamiento más largo, pero el resto de las solicitudes ahora se procesan dentro de una ventana corta, puede ignorar el retraso aparente y continuar probando con normalidad.

{% content-ref url="race-conditions/laboratorio-multi-endpoint-race-conditions" %}
[laboratorio-multi-endpoint-race-conditions](https://juanfelipeoz.gitbook.io/notes/portswigger-webacademy/server-side-topics/race-conditions/laboratorio-multi-endpoint-race-conditions)
{% endcontent-ref %}

#### Abusar los límites de tipos o recursos

Si el calentamiento de la conexión no hace ninguna diferencia, hay varias soluciones a este problema.

Usando Turbo Intruder, puede introducir un breve retraso en el lado del cliente. Sin embargo, como esto implica dividir sus solicitudes de ataque reales a través de varios paquetes TCP, usted no será capaz de utilizar la técnica de ataque de un solo paquete. Como resultado, en objetivos de alto jrúd, es poco probable que el ataque funcione de manera confiable independientemente del retraso que establezcas.

<figure><img src="https://2827710683-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FV9yg1NBoB0HDHj681gSk%2Fuploads%2Fsb3TiZ9mvVHeo9sdUHHt%2Fimagen.png?alt=media&#x26;token=748029a3-9d2b-43ba-b45c-5a0828b8fd01" alt=""><figcaption></figcaption></figure>

En su lugar, usted puede ser capaz de resolver este problema abusando de una característica de seguridad común.

Los servidores web a menudo retrasen el procesamiento de las solicitudes si se envían demasiado rápido. Al enviar un gran número de solicitudes ficcionadas para activar intencionalmente la tarifa o el límite de recursos, es posible que pueda causar un retraso adecuado del lado del servidor. Esto hace que el ataque de un solo paquete sea viable incluso cuando se requiere una ejecución tardía.

<figure><img src="https://2827710683-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FV9yg1NBoB0HDHj681gSk%2Fuploads%2FXgsujZa1rTE4Q7Iwtlk0%2Fimagen.png?alt=media&#x26;token=f66c5468-cab0-4fe7-be47-e737fbd39324" alt=""><figcaption></figcaption></figure>

### Condiciones de la carrera de un solo extremo (Single Endpoint)

Enviar solicitudes paralelas con diferentes valores a una sola variable a veces puede desencadenar poderosas condiciones de carrera.

Considere un mecanismo de restablecimiento de contraseña que almacena el ID de usuario y resticio de token en la sesión del usuario.

En este escenario, enviar dos solicitudes paralelas de restablecimiento de contraseña de la misma sesión, pero con dos nombres de usuario diferentes, podría potencialmente causar la siguiente colisión:

<figure><img src="https://2827710683-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FV9yg1NBoB0HDHj681gSk%2Fuploads%2FSdwph1oe32lblsUy9Kiz%2Fimagen.png?alt=media&#x26;token=4d0e998a-5baf-4585-b432-b5a69ad96b03" alt=""><figcaption></figcaption></figure>

Note the final state when all operations are complete:

* `session['reset-user'] = victim`
* `session['reset-token'] = 1234`

The session now contains the victim's user ID, but the valid reset token is sent to the attacker.

> Para que este ataque funcione, las diferentes operaciones realizadas por cada proceso deben ocurrir en el orden correcto. Probablemente requeriría múltiples intentos, o un poco de suerte, para lograr el resultado deseado.

Las confirmaciones de direcciones de correo electrónico, o cualquier operación basada en correo electrónico, son generalmente un buen objetivo para las condiciones de carrera de un solo punto. Los correos electrónicos a menudo se envían en un hilo de fondo después de que el servidor emite la respuesta HTTP al cliente, haciendo que las condiciones de la carrera sean más probables.

{% content-ref url="race-conditions/laboratorio-single-endpoint-race-conditions" %}
[laboratorio-single-endpoint-race-conditions](https://juanfelipeoz.gitbook.io/notes/portswigger-webacademy/server-side-topics/race-conditions/laboratorio-single-endpoint-race-conditions)
{% endcontent-ref %}

***

### Mecanismos de bloqueo basados en sesiones

Algunos marcos tratan de prevenir la corrupción accidental de datos utilizando algún tipo de bloqueo de solicitudes. Por ejemplo, el módulo de manejador de sesión nativa de PHP solo procesa una solicitud por sesión a la vez.

Es extremadamente importante detectar este tipo de comportamiento, ya que de lo contrario puede enmascarar vulnerabilidades triviamente explotables. Si te das cuenta de que todas tus solicitudes están siendo procesadas secuencialmente, intente enviarlas a cada una de ellas usando un símbolo de sesión diferente.

### Condiciones de la carrera de construcción parcial

Muchas aplicaciones crean objetos en múltiples pasos, que pueden introducir un estado medio temporal en el que el objeto es explotable.

Por ejemplo, al registrar un nuevo usuario, una aplicación puede crear el usuario en la base de datos y establecer su clave de API usando dos declaraciones SQL separadas. Esto deja una pequeña ventana en la que el usuario existe, pero su clave API no se presenta.

Este tipo de comportamiento allana el camino para las hazañas por las que se inyecta un valor de entrada que devuelve algo que coincida con el valor de base de datos no inicializado, como una cadena vacía, o `null`en JSON, y esto se compara como parte de un control de seguridad.

Los marcos a menudo le permiten pasar en matrices y otras estructuras de datos no encadenadas usando sintaxis no estándar. Por ejemplo, en PHP:

* `param[]=foo`es equivalente a `param = ['foo']`
* `param[]=foo&param[]=bar`es equivalente a `param = ['foo', 'bar']`
* `param[]`es equivalente a `param = []`

Ruby on Rails te permite hacer algo similar proporcionando una consulta o `POST`parámetro con una llave pero sin valor. En otras palabras `param[key]`resultados en el siguiente objeto del lado del servidor:

```json
params = {"param"=>{"key"=>nil}}
```

En el ejemplo anterior, esto significa que durante la ventana de la carrera, usted podría potencialmente hacer solicitudes de API autenticadas de la siguiente manera:

```http
GET /api/user/info?user=victim&api-key[]= HTTP/2
Host: vulnerable-website.com
```

#### Nota

Es posible causar colisiones de construcción parcial similares con una contraseña en lugar de una clave de la API. Sin embargo, como las contraseñas se han despreciado, esto significa que necesita inyectar un valor que haga que el hash digerido coincida con el valor no inicializado.

***

### Ataques sensibles al tiempo

A veces puede que no encuentres condiciones de carrera, pero las técnicas para entregar solicitudes con un momento preciso todavía pueden revelar la presencia de otras vulnerabilidades.

Un ejemplo es cuando se utilizan **timestamps** de alta resolución en lugar de cuerdas aleatorias criptográficamente seguras para generar fichas de seguridad.

Considere una ficha de restablecimiento de contraseña que sólo se aleatoriza usando una marca de tiempo. En este caso, podría ser posible activar dos resets de contraseñas para dos usuarios diferentes, que ambos utilizan el mismo token. Todo lo que tienes que hacer es timear las peticiones para que generen la misma **timestamp**.

{% content-ref url="race-conditions/laboratorio-partial-construction-race-condition" %}
[laboratorio-partial-construction-race-condition](https://juanfelipeoz.gitbook.io/notes/portswigger-webacademy/server-side-topics/race-conditions/laboratorio-partial-construction-race-condition)
{% endcontent-ref %}

***
