Use-After-Free en Netfilter nf_tables al procesar solicitudes por lotes

Demo

Detalles de la Vulnerabilidad

El código afectado proviene del kernel oficial de Linux desde https://kernel.org/ y forma parte del componente Netfilter nf_tables (net/netfilter/nf_tables_api.c).

Netfilter nf_tables permite actualizar su configuración como una operación atómica. Al usar esta característica, los clientes en modo usuario envían solicitudes por lotes que contienen una lista de operaciones básicas. Netfilter nf_tables procesa entonces todas las operaciones dentro del lote como una única transacción. Al procesar el lote, Netfilter nf_tables comprueba las actualizaciones del estado de la configuración para garantizar que cada operación básica sucesiva sea válida, y esto también tiene en cuenta las actualizaciones de estado de todas las operaciones anteriores dentro del lote. Sin embargo, la comprobación implementada actualmente es insuficiente.

En nuestro escenario específico comenzamos con una configuración de Netfilter nf_tables que tiene una nft_rule con la expresión lookup en un nft_set anónimo, y donde el nft_set anónimo contiene algunos elementos. A continuación, enviamos una solicitud por lotes que contiene las siguientes dos operaciones básicas:

1. Operación NFT_MSG_DELRULE para eliminar la nft_rule.
   Tenga en cuenta que esto también elimina implícitamente la expresión lookup y el nft_set anónimo.
2. Operación NFT_MSG_DELSETELEM para eliminar cualquiera de los elementos del nft_set anónimo eliminado.

La versión actual de Netfilter nf_tables acepta la solicitud por lotes anterior. Luego llama a nf_tables_commit_release(), que añade los recursos liberados a nf_tables_destroy_list. nf_tables_destroy_list es procesada entonces por nf_tables_trans_destroy_work(), que primero desasigna los recursos relacionados con la operación NFT_MSG_DELRULE llamando a:

nft_commit_release()
    nf_tables_rule_destroy()
        nf_tables_expr_destroy()
            expr->ops->destroy() that points to nft_lookup_destroy()
                nf_tables_destroy_set()
                    nft_set_destroy()
                        kvfree() that deallocates memory used by `nft_set`

antes de procesar la operación NFT_MSG_DELSETELEM, donde se accede a la referencia al nft_set desasignado mediante nft_trans_elem_set() durante las siguientes llamadas:

nft_commit_release()
    nf_tables_set_elem_destroy()
        nft_set_elem_ext()

Dentro de nft_set_elem_ext() anterior, se accede a la ubicación de memoria del nft_set desasignado para determinar la ubicación de nft_set_ext:

static inline struct nft_set_ext *nft_set_elem_ext(const struct nft_set *set,
                                                   void *elem)
{
        return elem + set->ops->elemsize;
}

para las operaciones que siguen. Por lo tanto, siempre que el valor de set->ops->elemsize se corrompa, cierta ubicación de memoria inesperada podría interpretarse como una lista de nft_expr a destruir:

static void nf_tables_set_elem_destroy(const struct nft_ctx *ctx,
                                       const struct nft_set *set, void *elem)
{
        struct nft_set_ext *ext = nft_set_elem_ext(set, elem);

        if (nft_set_ext_exists(ext, NFT_SET_EXT_EXPRESSIONS))
                nft_set_elem_expr_destroy(ctx, nft_set_ext_expr(ext));

Técnicas de Explotación

Explotar la vulnerabilidad anterior requiere ganar una carrera contra nf_tables_trans_destroy_work(), que se ejecuta desde el subproceso de trabajo en segundo plano del kernel de Linux. Esto parece complicar la explotación práctica incluso antes de considerar las mitigaciones existentes, como el endurecimiento del asignador de slabs del kernel, la aleatorización del diseño del espacio de direcciones del kernel (KASLR) y especialmente la integridad del flujo de control. Sin embargo, el PoC adjunto demuestra que todavía es posible lograr una explotación razonablemente fiable en la práctica.

Para explotar la vulnerabilidad, necesitamos modificar el contenido de la memoria del nft_set después de que se desasigne bajo nf_tables_rule_destroy(), pero antes de que se utilice bajo nf_tables_set_elem_destroy(). Tanto nf_tables_rule_destroy() como nf_tables_set_elem_destroy() se llaman dentro de una única invocación de nf_tables_trans_destroy_work(), que se ejecuta desde el subproceso de trabajo en segundo plano del kernel de Linux. Además, el bloque de memoria desasignado suele estar disponible para reutilizarse solo desde el mismo núcleo de la CPU.

Al competir con nf_tables_trans_destroy_work(), mejoramos nuestras posibilidades añadiendo un retraso controlado para el subproceso de trabajo en segundo plano entre las llamadas a nf_tables_rule_destroy() y nf_tables_set_elem_destroy(). Para ello, insertamos una operación adicional para destruir otro nft_set que contenga un gran número de elementos. Además, mantenemos ocupados todos los demás núcleos de la CPU, de modo que el subproceso de trabajo en segundo plano probablemente sea programado en un núcleo de CPU específico, para así intentar asignar una nueva estructura desde el mismo núcleo de CPU justo después de que desasigne nft_set bajo nf_tables_rule_destroy(). Nuestro objetivo es asignar un nuevo nft_set de tipo diferente para reutilizar la ubicación de memoria del nft_set desasignado bajo nf_tables_rule_destroy().

El nuevo tipo de nft_set se selecciona para usar un valor diferente para set->ops->elemsize. Así, cuando el subproceso de trabajo en segundo plano finalmente llama a nf_tables_set_elem_destroy() para procesar la operación NFT_MSG_DELSETELEM, interpreta su argumento elem incorrectamente, de modo que el nft_set_ext *ext corrupto se encuentra unos bytes después de la ubicación correcta. Esto significa que ciertos campos de datos controlados por el usuario del nft_set_ext original ahora se interpretan como cabeceras, lo que resulta en confusión de tipos.

Una forma de abusar de esta confusión de tipos es manipulando las cabeceras del nft_set_ext corrupto con valores de desplazamiento tales que nf_tables_set_elem_destroy() interprete el contenido de cualquier bloque de memoria adyacente como la lista de nft_expr a destruir mediante las siguientes llamadas:

nft_set_elem_expr_destroy()
    __nft_set_elem_expr_destroy()
        nf_tables_expr_destroy()
            expr->ops->destroy()

En este punto de la explotación, todavía no tenemos detalles del diseño de memoria del kernel. Por lo tanto, no es posible fabricar direcciones absolutas de punteros. Sin embargo, al manipular las cabeceras del nft_set_ext corrupto, todavía podemos usar desplazamientos fuera de rango, de modo que expr->ops->destroy() se llame sobre ciertos nft_expr válidos en los bloques de memoria adyacentes.

Para ello, rociamos expresiones nft_log, con NFTA_LOG_PREFIX controlado. Ese nft_log->prefix es desasignado entonces por nft_log_destroy() una vez que se llama a expr->ops->destroy():

static void nft_log_destroy(const struct nft_ctx *ctx,
                            const struct nft_expr *expr)
{
        struct nft_log *priv = nft_expr_priv(expr);
        struct nf_loginfo *li = &priv->loginfo;

        if (priv->prefix != nft_log_null_prefix)
                kfree(priv->prefix);

Tenga en cuenta que todavía podemos acceder e incluso desasignar nuevamente esta memoria a través de la otra referencia de la expresión nft_log rociada.