CVE-2026-19595

Estado: RecibidaMedia (6.1)—
Gravedad6.1Media · CVSS 3.1
Probabilidad de explotación0.11 %mayor que el 1 % de las CVE
Explotación activaNono figura en el catálogo de CISA
Exploit públicoNo conocidosin código público localizado

El verificador de llamadas al sistema en modo usuario z_vrfy_rtio_cqe_get_mempool_buffer() en subsys/rtio/rtio_syscalls.c validaba sus dos parámetros de salida, buff y buff_len, con K_SYSCALL_MEMORY_READ() en lugar de K_SYSCALL_MEMORY_WRITE(). Ambos son parámetros de salida puros: z_impl_rtio_cqe_get_mempool_buffer() almacena a través de ellos la dirección del búfer del mempool y su longitud.

Leer descripción completaMostrar menos

La distinción la aplican todos los validadores de arquitectura: arch_buffer_validate() en RISC-V PMP acepta explícitamente las regiones globales __rom_region/__rodata_region solo para lectura, y los validadores de la MPU de ARM aceptan las regiones P_RO_U_RO y P_RW_U_RO solo para lectura, por lo que un puntero validado para lectura no es necesariamente escribible por el hilo que realiza la llamada.

Un hilo en modo usuario sin privilegios al que se le ha concedido acceso a un contexto RTIO (rtio_access_grant()) puede invocar la llamada al sistema rtio_cqe_get_mempool_buffer() con buff/buff_len apuntando a memoria que puede leer pero no escribir, y con una entrada de la cola de finalización cuyo campo flags controla por completo. Solo se requiere RTIO_CQE_FLAG_MEMPOOL_BUFFER en flags[7:0]; flags[19:8] y flags[31:20] suministran el índice y el número de bloques. A continuación, el kernel realiza un almacenamiento de tamaño de puntero y otro de 4 bytes a través de esas direcciones mientras se ejecuta en modo supervisor. Para llegar a la escritura se requieren CONFIG_USERSPACE junto con CONFIG_RTIO_SYS_MEM_BLOCKS, la configuración que subyace a RTIO_DEFINE_WITH_MEMPOOL; sin esta última, la implementación devuelve -ENOTSUP y no escribe nada.

De ello se derivan dos consecuencias. Si el destino se encuentra en una partición de dominio de memoria declarada K_MEM_PARTITION_P_RW_U_RO (lectura y escritura privilegiada, solo lectura para usuario), el almacenamiento en modo kernel tiene éxito y deposita valores parcialmente elegidos por el atacante en memoria que el dominio de memoria había marcado como de solo lectura para ese hilo, eludiendo la protección de escritura de la partición. Si el destino se encuentra en memoria globalmente legible pero no escribible, como .text/.rodata en flash, el almacenamiento provoca un fallo en modo kernel; el fallo se entrega a z_fatal_error() y el k_sys_fatal_error_handler() por defecto detiene o reinicia el dispositivo, lo que permite a un hilo sin privilegios provocar una denegación de servicio total y fiable.

La comprobación de permiso de lectura sí limita el alcance del daño: la dirección debe seguir siendo legible por el hilo que realiza la llamada, por lo que no se puede apuntar a memoria privada del kernel y no se revela ningún dato confidencial. La corrección sustituye ambas comprobaciones por K_SYSCALL_MEMORY_WRITE(), de modo que un hilo sin permiso de escritura es terminado por K_OOPS antes de que se ejecute la implementación; el argumento cqe permanece correctamente validado para lectura.

Traducción automática del texto original de NVD (en inglés).

CVSS

Puntuación base
6.1
Versión
3.1
Vector
CVSS:3.1/AV:L/AC:L/PR:L/UI:N/S:U/C:N/I:L/A:H

Probabilidad de explotación (EPSS)

Probabilidad de explotación en los próximos 30 días
0.11 %
Percentil entre todas las CVEs puntuadas
1
Fecha de la puntuación
20/10/2026

EPSS (Exploit Prediction Scoring System, de FIRST) estima la probabilidad de que una vulnerabilidad sea explotada en 30 días. Complementa a CVSS (impacto) y a CISA KEV (explotación confirmada).

Técnicas ATT&CK

Cómo se explota esta vulnerabilidad y qué consigue el atacante, en el lenguaje de MITRE ATT&CK.

Vector AV:L/PR:L/UI:N: un hilo sin privilegios con acceso RTIO usa la syscall con un puntero solo legible; provoca fallo en modo kernel (DoS fiable) y escritura en memoria de solo lectura.

Inferido por nuestro agente de análisis a partir de la descripción oficial, el vector CVSS y la CWE, y comprobado por un supervisor. Puede contener errores.

Mitigaciones ATT&CK que cubren estas técnicas

Tecnologías afectadas (1)

⚠ Inferidas por IA a partir de la descripción — NVD aún no ha analizado esta CVE; no son CPE verificados.

CWE

Referencias

Mostrar las 2 referencias

JSON original (NVD)

Mostrar
{
  "id": "CVE-2026-19595",
  "cveTags": [],
  "metrics": {
    "cvssMetricV31": [
      {
        "type": "Secondary",
        "source": "vulnerabilities@zephyrproject.org",
        "cvssData": {
          "scope": "UNCHANGED",
          "version": "3.1",
          "baseScore": 6.1,
          "attackVector": "LOCAL",
          "baseSeverity": "MEDIUM",
          "vectorString": "CVSS:3.1/AV:L/AC:L/PR:L/UI:N/S:U/C:N/I:L/A:H",
          "integrityImpact": "LOW",
          "userInteraction": "NONE",
          "attackComplexity": "LOW",
          "availabilityImpact": "HIGH",
          "privilegesRequired": "LOW",
          "confidentialityImpact": "NONE"
        },
        "impactScore": 4.2,
        "exploitabilityScore": 1.8
      }
    ]
  },
  "affected": [
    {
      "source": "vulnerabilities@zephyrproject.org",
      "affectedData": [
        {
          "vendor": "zephyrproject",
          "product": "zephyr",
          "versions": [
            {
              "status": "affected",
              "version": "3.4.0",
              "versionType": "semver",
              "lessThanOrEqual": "4.4.2"
            }
          ],
          "packageName": "zephyr",
          "programFiles": [
            "subsys/rtio/rtio_handlers.c",
            "subsys/rtio/rtio_syscalls.c"
          ],
          "collectionURL": "https://github.com/zephyrproject-rtos/zephyr",
          "defaultStatus": "unaffected",
          "programRoutines": [
            {
              "name": "z_vrfy_rtio_cqe_get_mempool_buffer"
            }
          ]
        }
      ]
    }
  ],
  "published": "2026-10-19T23:17:36.717",
  "references": [
    {
      "url": "https://github.com/zephyrproject-rtos/zephyr/commit/bea93400138362691403b7f81de1e9048681547d",
      "source": "vulnerabilities@zephyrproject.org"
    },
    {
      "url": "https://github.com/zephyrproject-rtos/zephyr/security/advisories/GHSA-7337-mc44-5wjm",
      "source": "vulnerabilities@zephyrproject.org"
    }
  ],
  "vulnStatus": "Received",
  "weaknesses": [
    {
      "type": "Secondary",
      "source": "vulnerabilities@zephyrproject.org",
      "description": [
        {
          "lang": "en",
          "value": "CWE-787"
        },
        {
          "lang": "en",
          "value": "CWE-822"
        }
      ]
    }
  ],
  "descriptions": [
    {
      "lang": "en",
      "value": "The user-mode syscall verifier z_vrfy_rtio_cqe_get_mempool_buffer() in subsys/rtio/rtio_syscalls.c validated its two output parameters, buff and buff_len, with K_SYSCALL_MEMORY_READ() rather than K_SYSCALL_MEMORY_WRITE(). Both are pure out-parameters: z_impl_rtio_cqe_get_mempool_buffer() stores the mempool buffer address and its length through them. The distinction is enforced by every architecture validator — arch_buffer_validate() on RISC-V PMP explicitly accepts the global __rom_region/__rodata_region for reads only, and the ARM MPU validators accept P_RO_U_RO and P_RW_U_RO regions for reads only — so a read-validated pointer is not necessarily writable by the calling thread.\n\nAn unprivileged user-mode thread that has been granted access to an RTIO context (rtio_access_grant()) can invoke the rtio_cqe_get_mempool_buffer() syscall with buff/buff_len pointing at memory it may read but not write, and with a completion-queue entry whose flags field it fully controls (only RTIO_CQE_FLAG_MEMPOOL_BUFFER in flags[7:0] is required; flags[19:8] and flags[31:20] supply the block index and count). The kernel then performs a pointer-sized and a 4-byte store through those addresses while running in supervisor mode. Reaching the store requires CONFIG_USERSPACE together with CONFIG_RTIO_SYS_MEM_BLOCKS, the configuration behind RTIO_DEFINE_WITH_MEMPOOL; without the latter the implementation returns -ENOTSUP and writes nothing.\n\nTwo outcomes follow. If the target lies in a memory-domain partition declared K_MEM_PARTITION_P_RW_U_RO (privileged read-write, user read-only), the kernel-mode store succeeds and deposits partly attacker-chosen values into memory the memory domain had marked read-only for that thread, bypassing the partition's write protection. If the target lies in globally readable but unwritable memory such as .text/.rodata in flash, the store faults in kernel mode; the fault is delivered to z_fatal_error() and the default k_sys_fatal_error_handler() halts or reboots the device, giving an unprivileged thread a reliable full denial of service.\n\nThe read-permission check does bound the damage: the address must still be readable by the calling thread, so kernel-private memory cannot be targeted and no confidential data is disclosed. The fix replaces both checks with K_SYSCALL_MEMORY_WRITE(), so a thread lacking write permission is terminated by K_OOPS before the implementation runs; the cqe argument correctly remains read-validated."
    }
  ],
  "lastModified": "2026-10-19T23:17:36.717",
  "sourceIdentifier": "vulnerabilities@zephyrproject.org"
}