Título: Vulnerabilidad CVE-2026-13523 - Detalle CVSS, EPSS y CISA Kev

Resumen

Se ha identificado una debilidad en GPAC hasta la versión 26.02.0. Este problema afecta una parte desconocida del archivo src/utils/base_encoding.c del componente ISOBMFF Parser. La ejecución de un manejador puede llevar a datos comprimidos altamente comprimidos. El ataque debe ser lanzado localmente. El exploit ha sido publicado y podría usarse para ataques. Se aplica el parche 297f2d8d1f493d8b241330533cd47f7da758aeb3. Un parche debe aplicarse para remediar este problema. El proveedor confirma: "Añadimos un check en el tamaño de salida de inflación, si supera 32 veces el tamaño del input, detenemos en error. Este valor podría ser ajustado más tarde."

¿Qué es la vulnerabilidad/exploit?

Se ha identificado una debilidad en GPAC hasta la versión 26.02.0 que afecta un archivo desconocido de la carpeta src/utils/base_encoding.c del componente ISOBMFF Parser. La ejecución de un manejador puede llevar a datos comprimidos altamente comprimidos.

Explicación técnica para defensores

GPAC es una biblioteca multimedia que permite el manejo y creación de archivos MP4, M3U8 y otros formatos multimedia. El componente ISOBMFF Parser es responsable de analizar los archivos MP4 y M3U8. La debilidad se encuentra en la función inflate de la librería zlib, que se utiliza para comprimir y descomprimir datos.

Cuando un manejador manipula los datos comprimidos, puede producir datos altamente comprimidos que pueden ser peligrosos si no se manejan correctamente. El ataque debe ser lanzado localmente, ya que requiere acceso a la máquina donde se ejecuta GPAC.

El exploit ha sido publicado y podría usarse para ataques. Se aplica el parche 297f2d8d1f493d8b241330533cd47f7da758aeb3, que añade un check en el tamaño de salida de inflate para evitar que los datos comprimidos sean demasiado grandes.

Código seguro educativo

A continuación se presenta un ejemplo básico de código en C que utiliza zlib para comprimir y descomprimir datos. Este código incluye validaciones básicas para evitar errores comunes.

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <zlib.h>

#define BUFFER_SIZE 1024

void compress_data(const char *input, char **output) {
    int input_len = strlen(input);
    unsigned long output_len = compressBound(input_len);

    *output = (char *)malloc(output_len);
    if (*output == NULL) {
        fprintf(stderr, "Error: No se pudo reservar memoria.\n");
        return;
    }

    int result = compress(*output, &output_len, (unsigned char *)input, input_len);
    if (result != Z_OK) {
        free(*output);
        *output = NULL;
        fprintf(stderr, "Error al comprimir datos: %s\n", zerror(result));
        return;
    }

    // Eliminar bytes de padding
    output_len -= (*output)[output_len - 1];
}

void decompress_data(const char *input, char **output) {
    int input_len = strlen(input);
    unsigned long output_len = input_len;

    *output = (char *)malloc(output_len);
    if (*output == NULL) {
        fprintf(stderr, "Error: No se pudo reservar memoria.\n");
        return;
    }

    int result = uncompress(*output, &output_len, (unsigned char *)input, input_len);
    if (result != Z_OK) {
        free(*output);
        *output = NULL;
        fprintf(stderr, "Error al descomprimir datos: %s\n", zerror(result));
        return;
    }
}

int main() {
    const char *input = "Este es un ejemplo de texto para comprimir.";
    char *compressed = NULL;
    char *decompressed = NULL;

    compress_data(input, &compressed);
    if (compressed != NULL) {
        printf("Datos comprimidos:\n");
        printf("%s\n", compressed);

        decompress_data(compressed, &decompressed);
        if (decompressed != NULL) {
            printf("Datos descomprimidos:\n");
            printf("%s\n", decompressed);

            free(decompressed);
        }

        free(compressed);
    }

    return 0;
}

Explicación del código

1. **Comprimir datos**: La función `compress_data` comprime los datos proporcionados utilizando la biblioteca zlib. Se utiliza `compressBound` para calcular el tamaño necesario para el búfer de salida.
2. **Descomprimir datos**: La función `decompress_data` descomprime los datos comprimidos utilizando la biblioteca zlib.
3. **Validaciones**: El código incluye validaciones básicas para evitar errores comunes, como verificar que se haya reservado memoria correctamente y que el resultado de las funciones de compresión o descompresión sea correcto.

Riesgos de ejecución

**Error al reservar memoria**: Si no se puede reservar suficiente memoria, el código podría fallar.
**Error al comprimir/descomprimir**: Si hay un error en la compresión o descompresión, el código podría fallar y mostrar un mensaje de error.

Mitigación

1. **Validaciones**: Se incluyen validaciones para verificar que se haya reservado memoria correctamente y que el resultado de las funciones de compresión o descompresión sea correcto.
2. **Error handling**: Se manejan errores al reservar memoria y al comprimir/descomprimir.

Checklist de mitigación

1. **Validaciones**: Verificar que se haya reservado suficiente memoria correctamente y que el resultado de las funciones de compresión o descompresión sea correcto.
2. **Error handling**: Manejar errores al reservar memoria y al comprimir/descomprimir.

Referencias

[CVE-2026-13523 - Detalle CVSS, EPSS y CISA Kev | CVE Find](https://www.cvefind.com/es/cve/CVE-2026-13523.html)
[GitHub Security Advisories](https://github.com/gpac/gpac/commit/297f2d8d1f493d8b241330533cd47f7da758aeb3)
[NVD - CVE-2026-13523](https://nvd.nist.gov/vuln/detail/CVE-2026-13523)
[CWE-404 Improper Resource Shutdown or Release](https://cwe.mitre.org/data/definitions/404.html)
[CWE-409 Improper Handling of Highly Compressed Data (Data Amplification)](https://cwe.mitre.org/data/definitions/409.html)