GHSA-PM86-CC75-Q463
Use-after-free en backends KV de `surrealdb-core` mediante amplificación de fugas en `affinitypool::spawn_local`
CVSS:3.1/AV:L/AC:H/PR:L/UI:N/S:C/C:H/I:H/A:H
Fuente: GitHub
Ciclo de vida de la vulnerabilidad
| Fecha | Fase | Evento | Detalle |
|---|---|---|---|
| Remediación | Parche 3.3.0 | surrealdb · -25 d desde divulgación | |
| Divulgación | Publicada | GHSA-PM86-CC75-Q463 divulgada · CVSS 7.8 (GitHub) | |
| Monitoreo | Detectada | Ingresó al índice | |
| Monitoreo | Verificada | Última verificación contra las fuentes |
Resumen
`surrealdb-core` pasa estado prestado que no es `'static` a closures del pool de afinidad mediante `affinitypool::spawn_local`: un `tokio::sync::MutexGuard<Option<TransactionInner>>`, `&Transaction`, `&mut ScanStateKeys/Vals`, `&mut dyn KeyVisitor/ValVisitor`, `RwLockReadGuard` (mem / surrealkv) y un `ReadOptions` que contiene un `rocksdb_snapshot_t*` crudo (rocksdb). En `affinitypool 0.7.0` (fijado por `Cargo.lock`), `spawn_local` es una función **segura* cuya corrección depende por completo de que se ejecute el `Drop` del future devuelto: bloquea el hilo que hace el drop hasta que el worker deja de usar los préstamos. El código Rust seguro puede filtrar ese future (`mem::forget`, `Box::leak`, `ManuallyDrop`, un ciclo `Rc`/`Arc` o un future externo filtrado); los préstamos terminan entonces mientras el worker del pool sigue ejecutándose, lo que constituye un use-after-free sobre la asignación de la transacción. AddressSanitizer reporta `heap-use-after-free` (LECTURA de los datos del mutex liberado, y además una ESCRITURA cuando el worker desbloquea el `tokio::sync::Mutex` liberado) en el hilo del pool. No se necesita `unsafe` en el sitio de llamada; el disparador es alcanzable a través de la API pública. Upstream ya cambió ambas funciones `spawn_local` a `unsafe fn` en la rama 0.8 no publicada, con un contraejemplo ejecutable en `tests/unsound.rs`.
Detalles
Versión verificada. `surrealdb 3.3.0-nightly`, commit de git `18971ffba781a796c0ad3897bb4b82432c241e4c` (2026-09-04), crate `surrealdb-core 3.3.0-nightly`. Dependencia `affinitypool 0.7.0` (crates.io, checksum `c4a46f56d354df11b6bcd8ca4f84fa03ac816cc41c72568a1b337d8f7e5af90e`). Todavía no hemos mapeado el rango de versiones publicadas; las versiones cuyo `Cargo.lock` fija `affinitypool 0.7.0` y cuyas fuentes de `kvs/` contienen llamadas a `affinitypool::spawn_local` están afectadas. Por favor, establezcan los rangos finales afectados y parcheados al publicar.
Causa raíz.
- `affinitypool 0.7.0` `src/lib.rs:52` (función libre) y `src/lib.rs:184` (`Threadpool::spawn_local`) son funciones seguras y `pub` que reciben `F: FnOnce() -> R + Send + 'pool` (no `'static`). El tiempo de vida `'pool` se borra mediante `async_task::Builder::spawn_unchecked`; lo único que mantiene la corrección es `SpawnFuture::drop` (`src/local.rs:140-194`, `Task::cancel()` + `block_on` basado en parker). La documentación del propio módulo del crate (`src/local.rs:17-25`, "Leak amplification") indica que `mem::forget` anula esta garantía y que cerrarla requiere un cambio en la API.
- `surrealdb-core` mueve estado prestado al closure del pool. Ejemplo determinista: `count()` escribible en `surrealdb/core/src/kvs/rocksdb/mod.rs:2290-2297` (`affinitypool::spawn_local(move || self.count_blocking(rng, version, guard))`); despacho genérico en `kvs/rocksdb/inline_guard.rs:96-109`, usado por `run_blocking` y los drivers de lotes de cursores. `count_blocking` (`kvs/rocksdb/mod.rs:1073`) lee el guard en `:1081` (`guard.as_ref()`), construye `ReadOptions` a partir de `inner.snapshot` (`count_read_options`, `:1017`; el wrapper del snapshot posee el `rocksdb_snapshot_t` reservado con `malloc` al que hace referencia `ReadOptions`) y libera el guard al final (desbloqueo del mutex).
- En esta versión hay 17 rutas de despacho: 12 llamadas textuales a `spawn_local` (rocksdb 9, inline_guard 1, mem 1, surrealkv 1) más 5 indirectas a través de `InlineGuard::try_inline_or_offload` (`run_blocking` y cuatro drivers de cursores). Los métodos afectados incluyen `count`, `keys`/`keysr`, `scan`/`scanr`, `compact`, el cierre, las lecturas y escrituras puntuales, y `open_keys_cursor`/`open_vals_cursor` + `next_batch`/`for_each`.
Por qué el código seguro puede alcanzarlo. `kvs::Transaction` implementa `Deref<Target = kvs::Transactor>` (`kvs/tx.rs:598-604`); `Transactor` se reexporta públicamente (`kvs/mod.rs:78`) y sus métodos de bytes crudos (`count`, `get`, `set`, `open_keys_cursor`, …) usan la cota pública `K: IntoBytes + Debug` (`kvs/tr.rs:119,166,422,444`; `IntoBytes` se reexporta en `kvs/mod.rs:72` y se define en `kvs/into.rs:6`), no el `KVKey` restringido al crate. `surrealdb-core` es un crate publicado (`surrealdb/core/Cargo.toml:3 publish = true`), y otros crates del mismo workspace ya llaman a métodos de `Transactor` desde fuera del crate (`surrealdb/src/engine/local/mod.rs:770,779`). Por tanto, cualquier código Rust que tenga un `Datastore`/`Transaction` públicos puede construir el disparador.
Especificidad del modelo asíncrono (como contexto). Se requieren tres ingredientes: el waiter es un *valor de future* que el código seguro puede filtrar (por lo que la unión no puede ser un marco de pila que retorna, como en `std::thread::scope`); el estado suspendido contiene préstamos del llamador; y un ejecutor independiente sigue usando esos préstamos después de que termina la región del préstamo. La clase raíz "el destructor como barrera de seguridad" es compartida con `std::thread::scoped` anterior a la 1.0; el modelo asíncrono es lo que la hace alcanzable aquí.
Divulgación. No divulgado públicamente ni a terceros. Podemos proporcionar el informe técnico completo, el archivo fuente del PoC y su registro completo de ASan. El formulario de informes de GitHub no tiene campo para adjuntos, por lo que los publicaremos en el hilo del aviso o en un fork privado una vez que se confirme la recepción del informe.
PoC
Entorno: Linux x86_64, `cargo +nightly-2026-04-14`, AddressSanitizer. Se requiere `--target` para que `RUSTFLAGS` no se apliquen a build scripts ni a macros procedurales (Rust Unstable Book, "Sanitizer").
Disparador mínimo (solo API pública; sin `unsafe`):
````rust
use surrealdb_core::kvs::{Datastore, LockType, TransactionType, Transactor};
let ds = Datastore::new("rocksdb:///tmp/f1.db").await?; // público
let tx = ds.transaction(TransactionType::Write, LockType::Optimistic).await?;
let count_fut = Transactor::count(&tx, beg..end, None); // API de bytes crudos
let mut count_fut = Box::pin(count_fut);
assert!(count_fut.as_mut().now_or_never().is_none()); // el worker del pool arrancó
mem::forget(count_fut); // seguro; el préstamo termina
drop(tx); // libera Transaction/Mutex
// el worker sigue usando el guard/&Transaction liberado -> UAF
````
Ejecución:
````bash
RUSTFLAGS="-Zsanitizer=address" ASAN_OPTIONS=detect_leaks=0 cargo +nightly-2026-04-14 test --target x86_64-unknown-linux-gnu -p surrealdb-core --features kv-rocksdb --test f1_public_api_leak_uaf -- --ignored --nocapture --test-threads=1
````
Fragmentos clave:
````text
==...==ERROR: AddressSanitizer: heap-use-after-free ... READ of size 8 ... thread T194
#0 Option<TransactionInner>::as_ref
#1 Transaction::count_blocking kvs/rocksdb/mod.rs:1081
#2 Transactable::count::{closure...} kvs/rocksdb/mod.rs:2295
#8 affinitypool::Threadpool::spawn_local affinitypool-0.7.0/src/lib.rs:205
#11 affinitypool::Threadpool::spin_up <- worker del pool
previously allocated by thread T1 here:
#3 DatastoreFlavor::new_transaction kvs/ds.rs:777:42
#5 Datastore::transaction kvs/ds.rs:3354:77 <- API pública
````
Durante la investigación también se ejecutó una variante de control sin fuga del mismo despacho (`count_fut.await` en lugar de `mem::forget`), que pasa: el `Drop` del future bloquea hasta que el worker termina, por lo que no hay UAF y el resultado del conteo es correcto. Un fragmento está en `reproduce.md` §3.
El código fuente completo del PoC y la salida completa de AddressSanitizer están en los bloques desplegables siguientes.
<details>
<summary>PoC — código fuente completo (128 líneas; solo API pública, sin `unsafe`)</summary>
````rust
//! F1 PoC — public-API variant: only `surrealdb_core`'s public surface is used.
//!
//! This PoC demonstrates that the F1 use-after-free does not require any
//! crate-internal visibility — it uses only `surrealdb_core`'s public surface
//! (the same defect is also reachable from the internal KV path):
//!
//! * `Datastore::new` / `Datastore::transaction` / `TransactionType` / `LockType`
//! / `Transactor` / `IntoBytes` are all publicly re-exported
//! (`surrealdb_core::kvs`), and `surrealdb-core` is a published crate.
//! * `Transaction` implements `Deref<Target = Transactor>`, and the raw-bytes
//! `Transactor` methods (`count`, `get`, `set`, `open_keys_cursor`, …) are
//! `pub` with the public bounds `K: IntoBytes + Debug` — not the
//! crate-private `KVKey` trait used by the decoding `Transaction` wrappers.
//! So an external crate can call `Transactor::count(&txn, …)` directly.
//! * The writable RocksDB `count` path unconditionally dispatches the blocking
//! scan to the affinity pool with the inner `tokio::sync::MutexGuard` and
//! `&Transaction` moved into the closure
//! (`kvs/rocksdb/mod.rs:2290-2297`). Leaking that future with the safe
//! `mem::forget` ends the borrow while the pool worker is still scanning;
//! dropping the transaction then frees the memory the worker is using.
//!
//! So "who can leak?" is: **any Rust code holding a `Datastore`/`Transaction`
//! through the public API** (any downstream crate depending on
//! `surrealdb-core`, any sibling workspace crate, or in-crate code). It is still
//! a caller-side leak — no remote input (SurrealQL/JS/WASM/RPC) can call
//! `mem::forget` — but the previous "c
Incluye detalles técnicos publicados por el investigador. Úselos solo para validar y corregir sus propios sistemas.
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 | 3.3.0 | -25 d | 4.0.1 no afectada |
3.3.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-pm86-cc75-q463Las referencias externas se muestran para copiar: cve.llama.ec no lo redirige a otros sitios.
