Title: el kernel de Linux, Description: En el kernel de Linux, la siguiente vulnerabilidad ha sido resuelta:

net/sched: act_ct: Solo liberar el bloqueo de lectura RCU después de ct_ft

Al buscar una tabla de flujo en act_ct en tcf_ct_flow_table_get(), rhashtable_lookup_fast() abre y cierra internamente una sección crítica de lectura RCU antes de devolver ct_ft.
La tcf_ct_flow_table_cleanup_work() puede completarse antes de que se invoque refcount_inc_not_zero() sobre el ct_ft devuelto, lo que resulta en un UAF en el objeto ct_ft ya liberado. Esta vulnerabilidad puede conducir a la escalada de privilegios.

Análisis de [email protected]:
Al inicializar act_ct, se llama a tcf_ct_init(), lo que internamente dispara tcf_ct_flow_table_get().

static int tcf_ct_flow_table_get(struct net net, struct tcf_ct_params params)

{
                struct zones_ht_key key = { .net = net, .zone = params->zone };
                struct tcf_ct_flow_table ct_ft;
                int err = -ENOMEM;

                mutex_lock(&zones_mutex);
                ct_ft = rhashtable_lookup_fast(&zones_ht, &key, zones_params); // [1]
                if (ct_ft && refcount_inc_not_zero(&ct_ft->ref)) // [2]
                                goto out_unlock;
                ...
}

static __always_inline void rhashtable_lookup_fast(
                struct rhashtable ht, const void key,
                const struct rhashtable_params params)
{
                void obj;

                rcu_read_lock();
                obj = rhashtable_lookup(ht, key, params);
                rcu_read_unlock();

                return obj;
}

En [1], rhashtable_lookup_fast() busca y devuelve el ct_ft correspondiente de zones_ht. La búsqueda se realiza dentro de una sección crítica de lectura RCU a través de rcu_read_lock() / rcu_read_unlock(), lo que evita que el objeto sea liberado. Sin embargo, en el punto de retorno de la función, rcu_read_unlock() ya ha sido llamado, y no hay nada que impida que ct_ft sea liberado antes de alcanzar refcount_inc_not_zero(&ct_ft->ref) en [2]. Este intervalo se convierte en la ventana de carrera, durante la cual ct_ft puede ser liberado.

Proceso de Liberación:

tcf_ct_flow_table_put() se ejecuta a través de la ruta tcf_ct_cleanup() call_rcu() tcf_ct_params_free_rcu() tcf_ct_params_free() tcf_ct_flow_table_put().

static void tcf_ct_flow_table_put(struct tcf_ct_flow_table ct_ft)
{
                if (refcount_dec_and_test(&ct_ft->ref)) {
                                rhashtable_remove_fast(&zones_ht, &ct_ft->node, zones_params);
                                INIT_RCU_WORK(&ct_ft->rwork, tcf_ct_flow_table_cleanup_work); // [3]
                                queue_rcu_work(act_ct_wq, &ct_ft->rwork);
                }
}

En [3], tcf_ct_flow_table_cleanup_work() se programa como trabajo RCU

static void tcf_ct_flow_table_cleanup_work(struct work_struct work)

{
                struct tcf_ct_flow_table ct_ft;
                struct flow_block block;

                ct_ft = container_of(to_rcu_work(work), struct tcf_ct_flow_table,
                                                                rwork);
                nf_flow_table_free(&ct_ft->nf_ft);
                block = &ct_ft->nf_ft.flow_block;
                down_write(&ct_ft->nf_ft.flow_block_lock);
                WARN_ON(!list_empty(&block->cb_list));
                up_write(&ct_ft->nf_ft.flow_block_lock);
                kfree(ct_ft); // [4]

                module_put(THIS_MODULE);
}

tcf_ct_flow_table_cleanup_work() libera ct_ft en [4]. Cuando esta función se ejecuta entre [1] y [2], ocurre un UAF.

Esta condición de carrera tiene una ventana de carrera muy corta, lo que la hace generalmente difícil de activar. Por lo tanto, para activar la vulnerabilidad se insertó un msleep(100) después de [1].