Control de acceso roto en plugins de WordPress: cómo evitarlo
Control de acceso roto en plugins de WordPress: protege manejadores AJAX, admin-post y REST con comprobación de capacidades, nonces correctos y propiedad del objeto.
También en: English Deutsch Français Italiano Polski Português Türkçe
La mayoría de los fallos de control de acceso roto en plugins de WordPress nacen de una sola línea que falta: una comprobación de capacidades que nadie escribió. El manejador funciona, el nonce se verifica, la función sale a producción y cualquier Suscriptor con sesión iniciada puede llamarla. Este artículo está dirigido a desarrolladores de plugins y temas y a agencias que programan plugins a medida. Explica los patrones de código que originan estos fallos y las comprobaciones que los evitan.
Por qué el control de acceso roto encabeza la lista de vulnerabilidades explotadas en plugins de WordPress
El informe State of WordPress Security in 2026 de Patchstack, un informe de un proveedor con datos de 2025, concluyó que el control de acceso roto fue la categoría más explotada. El mismo informe contabilizó 11.334 vulnerabilidades nuevas en el ecosistema de WordPress, el 91 % de ellas en plugins. En los fallos más explotados, la mediana ponderada del tiempo hasta la explotación masiva fue de 5 horas. Si publicas un agujero, no tendrás días para corregirlo.
Aplicado a un plugin, el control de acceso roto significa un manejador de peticiones que modifica o revela datos sin comprobar quién los pide ni qué puede tocar esa persona. Todo manejador debería responder a cuatro preguntas, en este orden:
- ¿Ha iniciado sesión el usuario? Omítela solo si la acción es realmente pública.
- ¿Tiene permiso para hacerlo? Es la comprobación de capacidades.
- ¿Quería hacerlo? Es la comprobación del nonce contra CSRF.
- ¿Puede tocar este objeto concreto? Es una comprobación de propiedad o de metacapacidad sobre el ID.
Empieza por localizar todos los puntos de entrada de tu plugin
No se puede proteger lo que no se conoce. Cada lugar por el que una petición llega a tu código es una puerta: los hooks wp_ajax_ y wp_ajax_nopriv_, los hooks admin_post_ y admin_post_nopriv_ y las llamadas a register_rest_route(). También los manejadores en init o template_redirect que leen $_POST o $_GET, y los shortcodes o bloques que procesan datos de formularios.
Ejecuta estos comandos desde el directorio raíz de tu plugin:
# Registered entry points
grep -rnE "wp_ajax_|admin_post_|register_rest_route" --include='*.php' .
# Public ones deserve a second look
grep -rn "wp_ajax_nopriv_\|admin_post_nopriv_\|__return_true" --include='*.php' .
# Raw request data read anywhere
grep -rn '\$_POST\|\$_GET\|\$_REQUEST' --include='*.php' .
Vuelca los resultados en una tabla con una línea por punto de entrada y guárdala en el repositorio, junto al código:
| Punto de entrada | Tipo | Quién puede llamarlo |
|---|---|---|
myplugin_save_settings | AJAX | manage_options |
myplugin_export | admin-post | myplugin_export_entries |
GET /myplugin/v1/stats | REST | Público, solo lectura |
Si no sabes qué poner en la última columna de algún punto de entrada, acabas de encontrar tu primer fallo.
Manejadores AJAX: wp_ajax_nopriv_ y el current_user_can() que falta
wp_ajax_nopriv_{action} hace que una acción sea accesible sin iniciar sesión. Regístrala solo para acciones verdaderamente públicas, como un buscador del front-end. Con frecuencia se añade «para que el formulario también funcione con invitados» y se olvida que el manejador borra o exporta datos.
Tampoco wp_ajax_{action} a secas es una comprobación de permisos. Significa que cualquier usuario con sesión iniciada puede llamar a la acción, Suscriptores incluidos. No te fíes de is_admin(): devuelve true en todas las peticiones a admin-ajax.php y admin-post.php, porque esos archivos se cargan en el contexto de administración. Te dice dónde ha aterrizado la petición, no quién la ha enviado.
Un manejador que responde a las preguntas:
add_action( 'wp_ajax_myplugin_delete_entry', 'myplugin_ajax_delete_entry' );
// Deliberately no wp_ajax_nopriv_ hook.
function myplugin_ajax_delete_entry() {
if ( ! current_user_can( 'myplugin_manage_entries' ) ) {
wp_send_json_error( array( 'message' => 'Forbidden' ), 403 );
}
// Dies with a 403 if the nonce is missing or invalid.
check_ajax_referer( 'myplugin_delete_entry', 'nonce' );
$entry_id = isset( $_POST['entry_id'] ) ? absint( $_POST['entry_id'] ) : 0;
// ...ownership check and the actual work follow (see below).
wp_send_json_success();
}
Las comprobaciones de capacidad y de nonce pueden ir en cualquier orden. Lo que importa es que ambas se ejecuten antes de que el manejador lea o escriba nada. Usa una capacidad propia, como myplugin_manage_entries, cuando la acción no deba depender de los derechos completos de administrador. manage_options sirve si solo los administradores deben tener acceso.
Los manejadores admin_post_ siguen las mismas reglas. Solo cambia la respuesta:
add_action( 'admin_post_myplugin_export', 'myplugin_handle_export' );
function myplugin_handle_export() {
if ( ! current_user_can( 'myplugin_export_entries' ) ) {
wp_die( esc_html__( 'You are not allowed to do this.', 'myplugin' ), '', array( 'response' => 403 ) );
}
check_admin_referer( 'myplugin_export' ); // pairs with wp_nonce_field( 'myplugin_export' )
// ...
}
Los nonces protegen contra CSRF, no contra el usuario equivocado
Un nonce demuestra que la petición procede de un formulario o enlace generado por tu plugin. No demuestra que el usuario tenga permiso para realizar la acción. Lo dice también el manual para desarrolladores de WordPress. Aun así, muchos plugins vulnerables siguen tratando un wp_verify_nonce() superado como si fuera una autorización.
Hay tres razones por las que no puede serlo:
- Cualquiera que pueda cargar la página que imprime el nonce puede leerlo en el código fuente. Si tu nonce aparece en todas las pantallas de administración, o en el front-end, un Suscriptor lo tiene.
- Los nonces no son de un solo uso. Por defecto, un nonce sigue siendo válido hasta 24 horas.
- Los nonces creados para visitantes sin sesión se comparten entre todos los visitantes sin sesión, así que protegen muy poco.
Combina cada comprobación de nonce con una comprobación de capacidades. Genera el nonce solo en las pantallas que ven los usuarios con la capacidad correspondiente. Usa un nombre de acción específico para cada operación, como myplugin_delete_entry_42 o, como mínimo, myplugin_delete_entry, en lugar de un único myplugin_nonce para todo el plugin.
Rutas REST: escribe un permission_callback que compruebe de verdad
'permission_callback' => '__return_true' significa «cualquiera en internet». Úsalo solo para datos públicos de solo lectura que ya sean visibles en otra parte del sitio. Nunca en rutas que escriben o borran, ni en las que devuelven datos personales o ajustes.
add_action( 'rest_api_init', function () {
register_rest_route( 'myplugin/v1', '/entries/(?P<id>\d+)', array(
'methods' => WP_REST_Server::EDITABLE,
'callback' => 'myplugin_rest_update_entry',
'permission_callback' => function ( WP_REST_Request $request ) {
return current_user_can( 'edit_post', (int) $request['id'] );
},
'args' => array(
'id' => array(
'validate_callback' => function ( $value ) {
return is_numeric( $value );
},
'sanitize_callback' => 'absint',
),
'title' => array(
'type' => 'string',
'sanitize_callback' => 'sanitize_text_field',
),
),
) );
} );
Si la comprobación falla, debe devolver false o un WP_Error. WordPress responde entonces con 401 a las peticiones anónimas y con 403 a los usuarios con sesión pero sin permiso. No hagas la comprobación de permisos dentro de callback: reparte la lógica y dificulta las revisiones. El manual de la API REST sobre endpoints personalizados trata la validación de args con más detalle.
Las peticiones REST autenticadas por cookie que haga tu propio JavaScript deben enviar un nonce wp_rest en la cabecera X-WP-Nonce. Sin él, WordPress trata la petición como si no hubiera sesión. Eso es protección CSRF, no autorización, así que el permission_callback sigue teniendo que comprobar. El endpoint de usuarios integrado y las fugas de nombres de usuario son otro tema, tratado en enumeración de usuarios en WordPress.
Nunca confíes en el ID de un objeto que llega en la petición
Es el patrón de referencia directa e insegura a objetos. Un manejador toma de la petición el ID de una entrada, un pedido, un registro o un archivo y lo usa sin comprobar a quién pertenece. La comprobación de capacidades se supera porque el usuario puede editar algunos registros, y por eso nada le impide editar cualquiera.
Para entradas y tipos de contenido personalizados, usa metacapacidades con el ID, como current_user_can( 'edit_post', $post_id ) o current_user_can( 'delete_post', $post_id ). Sin el ID, WordPress no puede asociar la comprobación al autor, el estado y el tipo de la entrada. Llamar a current_user_can( 'edit_post' ) sin más da un resultado sin sentido.
Para tablas propias, incluye la comprobación de propiedad en la propia consulta:
global $wpdb;
$table = $wpdb->prefix . 'myplugin_entries';
$deleted = $wpdb->query(
$wpdb->prepare(
"DELETE FROM {$table} WHERE id = %d AND owner_id = %d",
$entry_id,
get_current_user_id()
)
);
if ( ! $deleted ) {
wp_send_json_error( array( 'message' => 'Not found' ), 404 );
}
Devolver 404 en lugar de 403 evita confirmar que existe el registro de otra persona. En las acciones de «mi cuenta», toma el usuario de get_current_user_id() y no aceptes nunca un user_id procedente de la petición.
Imagina un plugin de formularios de contacto que guarda los mensajes en la base de datos. Su acción «exportar entradas» está registrada en wp_ajax_ con una comprobación de nonce y nada más. Cualquier Suscriptor registrado puede entonces descargar todos los mensajes enviados desde el sitio. En cuanto alguien aproveche ese agujero, cada sitio afectado sufre una violación de la seguridad de los datos personales conforme al RGPD, con el plazo de notificación de 72 horas que eso conlleva.
Lista de revisión de control de acceso para cada versión
- Cada punto de entrada figura en la lista con su público previsto.
- No existe ningún hook
noprivsin un motivo escrito en el código. - Todo manejador llama a
current_user_can()antes de leer o escribir datos. - Los nonces usan nombres de acción específicos y se verifican en cada manejador.
- Ninguna ruta REST que escriba, borre o devuelva datos privados usa
__return_true. - Los ID de objeto se comprueban con metacapacidades o con una columna de propietario.
- Las capacidades personalizadas se añaden al activar el plugin y se eliminan al desinstalarlo.
- La ruta de error devuelve 401/403 (o 404) sin filtrar datos ni trazas de la pila.
- Las pruebas automatizadas confirman que una petición de Suscriptor y una sin sesión se rechazan en cada acción privilegiada.
- Cada diff se revisa en busca de hooks, rutas y lecturas de
$_POST/$_GETnuevos.
Con la configuración de PHPUnit de WordPress, estas pruebas cuestan poco:
public function test_subscriber_cannot_update_entry() {
wp_set_current_user( self::factory()->user->create( array( 'role' => 'subscriber' ) ) );
$request = new WP_REST_Request( 'POST', '/myplugin/v1/entries/' . $this->post_id );
$response = rest_get_server()->dispatch( $request );
$this->assertSame( 403, $response->get_status() );
}
El plugin gratuito Security Audit & Compliance de secaudit.eu incluye un análisis de vulnerabilidades del código (análisis de taint) de plugins y temas. Considéralo un segundo par de ojos, no un sustituto de la revisión.
Cuando alguien notifica un agujero: gestión de vulnerabilidades y el CRA
Un plugin o tema de pago vendido a clientes de la UE es un producto con elementos digitales según el Reglamento de Ciberresiliencia (CRA), y quien lo vende es el fabricante. Desde el 11 de septiembre de 2026, las vulnerabilidades explotadas activamente deben notificarse a través de la Single Reporting Platform de ENISA. Los plazos son una alerta temprana en 24 horas, una notificación en 72 horas y un informe final en un máximo de 14 días tras disponer de una corrección. A partir del 11 de diciembre de 2027 se exigen un proceso de gestión de vulnerabilidades y una política de divulgación coordinada. Los detalles están en nuestra guía del CRA para vendedores de plugins.
Facilita que puedan contactarte con un archivo security.txt y un buzón que alguien lea. Cuando llegue un aviso, corrige el problema y publica la versión. Escribe en el registro de cambios una línea que nombre con claridad la corrección de seguridad e indica a tus clientes que actualicen. Los consejos para propietarios de sitios sobre cómo aplicar esas actualizaciones están en Plugins de WordPress vulnerables: auditar, actualizar, sustituir.
Tu próximo paso hoy: ejecuta los tres comandos grep de arriba en tu plugin y rellena la tabla de puntos de entrada.
Preguntas frecuentes
¿Basta is_user_logged_in() para proteger una acción?
No. Un Suscriptor también ha iniciado sesión. is_user_logged_in() responde solo a la primera de las cuatro preguntas, así que añade siempre una comprobación de capacidades.
¿Se puede reutilizar un nonce?
Sí, durante su periodo de validez, que por defecto es de hasta 24 horas. Un nonce no es un token de un solo uso ni un permiso, así que combínalo con current_user_can().
¿Se puede confiar en el rol Suscriptor?
No. En muchos sitios cualquiera puede registrarse como Suscriptor (Ajustes > Generales > Membresía). Trata las cuentas de Suscriptor como no fiables y prueba contra ellas cada acción privilegiada.
Este artículo es información general y no constituye asesoramiento jurídico.
Compruebe su propio sitio
Security Audit & Compliance es el plugin de WordPress de secaudit.eu: busca malware, spam oculto, archivos del núcleo modificados y código vulnerable, y relaciona sus hallazgos con el art. 32 del RGPD, el art. 21 de NIS2 y el OWASP Top 10.
Ver qué comprueba el plugin