Skip to content

6. Ámbitos de los datos

Una aplicación web atiende a muchos usuarios a la vez, y cada usuario realiza numerosas solicitudes. Por lo tanto, los datos pueden compartirse en varios niveles, conocidos como su ámbito:

  • ámbito de aplicación: los datos son compartidos por todos los usuarios durante toda la vida de la aplicación (la lista de médicos, por ejemplo);
  • ámbito de solicitud: los datos existen solo mientras se procesa una solicitud (el modelo de una vista, el usuario conectado tal como se identificó para esa solicitud);
  • ámbito de sesión: los datos son específicos de un usuario y deben persistir de una solicitud a la siguiente (el idioma seleccionado, un carrito de compras);
  • ámbito de cliente: datos almacenados en el propio navegador, en una cookie.

En [PHP], estos ámbitos se comportan de una manera particular porque la aplicación se reconstruye con cada solicitud (Ejemplo 01): nada sobrevive en memoria de una solicitud a la siguiente. Por lo tanto, todo dato que deba durar más que una sola solicitud se almacena fuera de [PHP]: en el caché, en una base de datos, en archivos o del lado del cliente. Esta es la arquitectura denominada “shared-nothing” (sin nada compartido): cada solicitud la procesa de forma aislada un proceso que no comparte nada con los que procesan otras solicitudes. Este enfoque tiene ventajas importantes: un error afecta solo a una solicitud, no se filtran datos de un usuario a otro y se pueden ejecutar varios servidores idénticos detrás de un balanceador de carga, siempre que compartan el mismo caché y la misma base de datos.

En [Symfony], cada ámbito tiene su propio contenedor:

Ámbito
Contenedor
Duración
aplicación
el caché (servicio [cache.app], ejemplo 20) o la base de datos
la duración elegida, o ilimitada
Solicitud
los servicios del contenedor (un objeto por clase, durante la solicitud), los atributos de la solicitud (ejemplo 12)
el procesamiento de una solicitud
sesión
la sesión ([$request->getSession()], Ejemplo 20), mantenida por el servidor y recuperada mediante una cookie
hasta que se cierra el navegador de forma predeterminada y, como máximo, durante la sesión de [PHP] (24 minutos de inactividad de forma predeterminada)
cliente
una cookie ([Cookie::create], ejemplo 22), en texto plano
El tiempo de expiración de la cookie

La sesión de [Symfony] es una sesión del lado del servidor, como las de [Java] ([JSESSIONID]) o las del [PHP] estándar, de las que de hecho toma prestados el mecanismo y la cookie ([PHPSESSID]): sus datos se almacenan en el servidor (un archivo por sesión, con la configuración usada en nuestros ejemplos) y el navegador solo guarda el identificador, un número aleatorio imposible de adivinar. Esto difiere de [Flask], cuya sesión completa se almacena en una cookie firmada del lado del cliente.

6.1. Ejemplo 23: ámbitos

23-scopes/
├── config/
│   └── packages/
│       ├── framework.yaml
│       └── twig.yaml
├── src/
│   ├── Controller/
│   │   └── ScopesController.php
│   └── Service/
│       ├── CounterService.php
│       ├── SignedCookies.php
│       └── RequestInfo.php
├── templates/
│   └── scopes/
│       └── scopes.html.twig
└── ...

El archivo [config/packages/framework.yaml] configura la sesión y los bloqueos, como en el Ejemplo 20.

6.1.1. Los objetos: src/Service/CounterService.php y RequestInfo.php

<?php
// src/Service/CounterService.php: ámbito de APLICACIÓN, contadores compartidos por
// todas las solicitudes de todos los usuarios, almacenados en el caché (véase el ejemplo 20)

namespace App\Service;

use Psr\Cache\CacheItemPoolInterface;
use Symfony\Component\Lock\LockFactory;

class CounterService
{
    public function __construct(
        private CacheItemPoolInterface $cache,
        private LockFactory $locks,
    ) {
    }

    // un número más bajo la clave [$key]; el caché "file" no incrementa un
    // número de forma atómica: un bloqueo protege la lectura y la escritura
    public function next(string $key): int
    {
        $lock = $this->locks->createLock("$key-lock");
        $lock->acquire(true);
        try {
            $item = $this->cache->getItem($key);
            $value = ($item->isHit() ? $item->get() : 0) + 1;
            $this->cache->save($item->set($value));
            return $value;
        } finally {
            $lock->release();
        }
    }

    public function increment(): int
    {
        return $this->next('visits');
    }
}
  • líneas 12–16: el servicio recibe el caché de la aplicación y la fábrica de bloqueos (Ejemplo 20);
  • líneas 20–32: un contador de ámbito de aplicación: un número almacenado en el caché bajo una clave e incrementado en 1 en cada llamada. El caché de “archivos” de nuestros ejemplos no admite operaciones de incremento atómicas: el valor debe leerse, incrementarse y luego escribirse, y dos solicitudes concurrentes podrían leer el mismo valor, con lo que se perdería una visita. Por lo tanto, un bloqueo (uno por clave) protege tanto la lectura como la escritura; el bloque [finally] lo libera en todos los casos, incluso después del [return] de la línea 28;
  • líneas 34–37: el contador de visitas.
<?php
// src/Service/RequestInfo.php: ámbito de SOLICITUD, la información de una solicitud

namespace App\Service;

use DateTimeImmutable;

class RequestInfo
{
    public readonly int $number;

    public readonly string $start;

    // el contenedor crea UN objeto de esta clase, en la primera petición del mismo, y
    // luego lo devuelve a todos los que lo piden durante la solicitud
    public function __construct(CounterService $counter)
    {
        // un número por OBJETO creado, tomado de un contador compartido por todas las solicitudes
        $this->number = $counter->next('instances');
        // la hora, con sus milisegundos (v)
        $this->start = (new DateTimeImmutable())->format('H:i:s.v');
    }
}
  • líneas 10–12: propiedades declaradas como [readonly] una por una (en lugar de toda la clase): solo se pueden asignar una vez, mediante el constructor;
  • líneas 16–22: información de ámbito de solicitud: un número, derivado de un contador compartido por todas las solicitudes (el servicio anterior, bajo otra clave), y la hora de la solicitud, con milisegundos (formato [v]). El constructor recibe el [CounterService] del contenedor: un servicio puede solicitar otro servicio, igual que una acción.

No se requiere ninguna configuración: de forma predeterminada, un servicio del contenedor es compartido (shared). El contenedor crea el objeto en la primera solicitud y luego devuelve el mismo a todas las solicitudes posteriores. En el modo [PHP] estándar, el contenedor se reconstruye con cada solicitud: un servicio compartido es, por lo tanto, un objeto de ámbito de solicitud. (También se puede solicitar un objeto nuevo en cada inyección mediante la opción [shared: false] en el archivo [services.yaml].) Surge un matiz con los servidores de aplicaciones que mantienen la aplicación en memoria de una solicitud a la siguiente para mejorar el rendimiento, como el modo worker de [FrankenPHP]: en este caso, un servicio es compartido por todas las solicitudes atendidas por el proceso. [Symfony] restablece entonces, entre solicitudes, los servicios que implementan la interfaz [ResetInterface]; corresponde a esos servicios garantizar que no se conserve nada de una solicitud a la siguiente.

6.1.2. Una variable global para las vistas: config/packages/twig.yaml

1
2
3
4
5
6
7
# config/packages/twig.yaml: la configuración del TwigBundle
twig:
    default_path: '%kernel.project_dir%/templates'
    # una variable GLOBAL de las vistas, que es un SERVICIO (la @ designa un servicio):
    # el objeto RequestInfo de la solicitud actual
    globals:
        info: '@App\Service\RequestInfo'
  • Líneas 6–7: una variable global en las vistas (Ejemplo 15) puede ser un servicio: el nombre de su clase, precedido por [@]. Así, todas las vistas tienen acceso a la variable [info], que es el objeto [RequestInfo] de la solicitud actual. [Twig] no tiene equivalente a la directiva [@inject] de [Blade]: una vista no solicita nada al contenedor; recibe lo que se le entrega.

6.1.3. Cookies firmadas: src/Service/SignedCookies.php

Una cookie es un dato confiado al cliente, que puede leerlo y modificarlo. [Laravel] cifra sus cookies; [Symfony] no lo hace. Sin embargo, para que una cookie sea confiable, basta con que esté firmada: su valor se transmite en texto plano, pero va seguido de una firma que solo el servidor sabe calcular, porque depende de una clave secreta. Un valor modificado por el cliente deja de tener la firma correcta y el servidor lo rechaza.

<?php
// src/Service/SignedCookies.php: cookies FIRMADAS. El valor viaja en texto claro,
// seguido de una firma que solo el servidor sabe calcular: un valor modificado
// por el cliente ya no tiene la firma correcta y se rechaza

namespace App\Service;

use Symfony\Component\DependencyInjection\Attribute\Autowire;

class SignedCookies
{
    // la clave de la firma: el secreto de la aplicación (APP_SECRET, archivo .env)
    public function __construct(#[Autowire('%kernel.secret%')] private string $secret)
    {
    }

    // "5" -> "5.3f1c...": el valor, un punto, la firma (HMAC-SHA256 del valor)
    public function sign(string $value): string
    {
        return $value.'.'.hash_hmac('sha256', $value, $this->secret);
    }

    // el valor si la firma es la correcta, null en caso contrario
    public function verify(?string $cookie): ?string
    {
        if ($cookie === null || ! str_contains($cookie, '.')) {
            return null;
        }
        // strrpos: la posición del ÚLTIMO punto
        $value = substr($cookie, 0, strrpos($cookie, '.'));
        // hash_equals compara dos cadenas en un tiempo constante, que no revela
        // a un atacante cuántos caracteres son correctos
        return hash_equals($this->sign($value), $cookie) ? $value : null;
    }
}
  • línea 13: la clave de firma es el secreto de la aplicación (la variable [APP_SECRET] del archivo [.env] , Ejemplo 01), que el contenedor reconoce como el parámetro [kernel.secret]. Un parámetro no es un objeto: el atributo [#[Autowire]] indica al contenedor el valor que debe proporcionar, donde [%name%] hace referencia a un parámetro;
  • líneas 18–21: la firma es un HMAC (Hash-based Message Authentication Code): el hash SHA-256 del valor, calculado con la clave secreta y escrito en hexadecimal. La cookie contiene el valor, un punto y luego la firma;
  • Líneas 24–34: el proceso de verificación vuelve a calcular la firma del valor recibido y la compara con la de la cookie. [hash_equals] compara dos cadenas en un tiempo que no depende del número de caracteres idénticos: una comparación estándar se detendría en el primer carácter distinto, y un atacante podría, midiendo el tiempo de respuesta, adivinar la firma carácter por carácter.

Este es el principio en que se basa el token JWT, que el próximo capítulo utilizará para la autenticación.

6.1.4. El controlador: src/Controller/ScopesController.php

<?php
// src/Controller/ScopesController.php: los cuatro ámbitos de datos

namespace App\Controller;

use App\Service\CounterService;
use App\Service\SignedCookies;
use App\Service\RequestInfo;
use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
use Symfony\Component\HttpFoundation\Cookie;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\Routing\Attribute\Route;

class ScopesController extends AbstractController
{
    // los servicios los proporciona el contenedor (véase el ejemplo 06)
    #[Route('/', name: 'scopes', methods: ['GET'])]
    public function display(Request $request, CounterService $counter, RequestInfo $info,
        SignedCookies $cookies): Response
    {
        // APLICACIÓN: el contador compartido
        $total = $counter->increment();
        // SESIÓN: datos específicos de ESTE navegador, conservados por el SERVIDOR
        // (un archivo de var/sessions), encontrados de nuevo gracias a la cookie de sesión
        $session = $request->getSession();
        $session->set('visits', $session->get('visits', 0) + 1);
        // CLIENTE: datos conservados por el NAVEGADOR en cookies,
        // reenviadas al servidor con cada solicitud; una en texto claro, la otra firmada
        $myVisits = (int) $request->cookies->get('myVisits') + 1;
        $mySignedVisits = (int) $cookies->verify($request->cookies->get('mySignedVisits')) + 1;
        $response = $this->render('scopes/scopes.html.twig', [
            'total' => $total, 'instance' => $info->number,
            'sessionVisits' => $session->get('visits'), 'myVisits' => $myVisits,
            'mySignedVisits' => $mySignedVisits,
        ]);
        $response->headers->setCookie(Cookie::create('myVisits', (string) $myVisits));
        $response->headers->setCookie(Cookie::create('mySignedVisits', $cookies->sign((string) $mySignedVisits)));
        return $response;
    }
}
  • líneas 19–20: la acción recibe la solicitud y tres servicios proporcionados por el contenedor;
  • línea 23: el ámbito de aplicación;
  • líneas 26–27: el ámbito de sesión. [$request->getSession()] devuelve la sesión del usuario; [get(key, default)] lee un valor y [set(key, value)] lo escribe. [Symfony] guarda la sesión al final de la solicitud;
  • Líneas 30–31: el ámbito de cliente, con dos cookies. Sus valores son cadenas proporcionadas por el navegador y, por lo tanto, pueden faltar o ser inválidos: la conversión [(int)] devuelve 0 para [null] o para un texto que no es un número. El valor de la cookie firmada solo se acepta si su firma es correcta;
  • líneas 32–39: para establecer una cookie se necesita el objeto de respuesta: [render] lo construye (ejemplo 13) y luego [setCookie] le agrega las cookies. Sin fecha de expiración, una cookie dura hasta que se cierra el navegador (es una cookie “de sesión”, según la definición de los navegadores).

6.1.5. La vista: templates/scopes/scopes.html.twig

<!doctype html>
<html lang="en">
<head>
  <meta charset="utf-8">
  <meta name="viewport" content="width=device-width, initial-scale=1">
  <title>Scopes</title>
  <link rel="stylesheet" href="{{ path('bootstrap', {file: 'css/bootstrap.min.css'}) }}">
</head>
<body>
  <div class="container py-3">
    <h1 class="h3">The scopes of data</h1>
    {# info: la variable global de config/packages/twig.yaml, un servicio; durante
       la MISMA solicitud, es el mismo objeto que el de la acción #}
    <ul>
      <li>application: {{ total }} visit(s) to the site, all browsers combined</li>
      <li>request: object no. {{ instance }} (no. {{ info.number }} in the view),
        request received at {{ info.start }}</li>
      {# app.session: la sesión, también accesible en las vistas #}
      <li>session: {{ sessionVisits }} visit(s) from this browser ({{ app.session.get('visits') }} in the view)</li>
      <li>client: {{ myVisits }} visit(s) from this browser (clear-text cookie),
        {{ mySignedVisits }} (signed cookie)</li>
    </ul>
  </div>
</body>
</html>
  • línea 16: [info], la variable global: durante la misma solicitud, es el mismo objeto [RequestInfo] que el de la acción; la vista muestra su número, que debe ser el recibido de la acción;
  • línea 19: la sesión también es accesible en las vistas mediante la variable [app.session].

6.1.6. Ejecución

Después de algunas visitas en un navegador:

Image

Sigamos las solicitudes con [curl], que actúa como un primer navegador y almacena sus cookies en el archivo [a.txt]:

curl -i -c a.txt -b a.txt http://localhost:8000/
HTTP/1.1 200 OK
...
Set-Cookie: myVisits=1; path=/; httponly; samesite=lax
Set-Cookie: mySignedVisits=1.e50058404359cc9be2e65b8d9366aa98b7d7db4ca7ee576cfdffb6d1a1150d37; path=/; httponly; samesite=lax
Set-Cookie: PHPSESSID=32da14307b05da3847ea54b2ae3e6f77; path=/; httponly; samesite=lax
...
      <li>application: 1 visit(s) to the site, all browsers combined</li>
      <li>request: object no. 1 (no. 1 in the view),
        request received at 09:48:29.888</li>
            <li>session: 1 visit(s) from this browser (1 in the view)</li>
      <li>client: 1 visit(s) from this browser (clear-text cookie),
        1 (signed cookie)</li>
...

La respuesta establece tres cookies. La primera, [myVisits], contiene el valor en texto plano. La segunda, [mySignedVisits], contiene el mismo valor, seguido de un punto y su firma. La tercera, [PHPSESSID], es el ID de sesión. Los datos de la sesión se almacenan en un archivo en el servidor, [var/sessions/dev/sess_32da14307b05da3847ea54b2ae3e6f77], cuyo nombre coincide con el ID de sesión:

_sf2_attributes|a:1:{s:6:"visits";i:1;}_sf2_meta|a:3:{s:1:"u";i:1790502509;s:1:"c";i:1790502509;s:1:"l";i:0;}

En el formato de serialización de [PHP], vemos un arreglo con una sola clave, [visits], y un valor entero de 1 ([i:1]), seguido de información de [Symfony] sobre la sesión (fechas de creación y de último uso). Una segunda visita, con las mismas cookies:

curl -i -c a.txt -b a.txt http://localhost:8000/
...
Set-Cookie: myVisits=2; path=/; httponly; samesite=lax
Set-Cookie: mySignedVisits=2.4c7239f31c7e195c32dc5dcf2c7734ea05e6cb316eeab9a53239ab047db525ff; path=/; httponly; samesite=lax
...
      <li>application: 2 visit(s) to the site, all browsers combined</li>
      <li>request: object no. 2 (no. 2 in the view),
        request received at 09:48:32.813</li>
            <li>session: 2 visit(s) from this browser (2 in the view)</li>
      <li>client: 2 visit(s) from this browser (clear-text cookie),
        2 (signed cookie)</li>
...

La sesión ya existe: la cookie [PHPSESSID] no se vuelve a enviar. Un segundo “navegador”, con su propio archivo de cookies, que inicialmente está vacío:

curl -c b.txt -b b.txt http://localhost:8000/
1
2
3
4
5
6
      <li>application: 3 visit(s) to the site, all browsers combined</li>
      <li>request: object no. 3 (no. 3 in the view),
        request received at 09:48:32.826</li>
            <li>session: 1 visit(s) from this browser (1 in the view)</li>
      <li>client: 1 visit(s) from this browser (clear-text cookie),
        1 (signed cookie)</li>

El contador de la aplicación ha continuado; la sesión y las cookies del segundo navegador comienzan de nuevo en 1. Cada solicitud tuvo su propio objeto [RequestInfo], y en cada una, la acción y la vista vieron el mismo. Por último, un usuario malintencionado falsifica sus propias cookies: 1000 visitas en [myVisits], 999 en [mySignedVisits] (con una firma inventada) y un ID de sesión de su propia invención:

curl -i -b "myVisits=1000;mySignedVisits=999.abc;PHPSESSID=abc" http://localhost:8000/
1
2
3
4
5
6
7
8
...
Set-Cookie: PHPSESSID=1885ac965cf2dc862c4aecb994300956; path=/; httponly; samesite=lax
...
      <li>application: 4 visit(s) to the site, all browsers combined</li>
      ...
            <li>session: 1 visit(s) from this browser (1 in the view)</li>
      <li>client: 1001 visit(s) from this browser (clear-text cookie),
        1 (signed cookie)</li>

La cookie en texto plano se aceptó tal cual: 1001 visitas. En cambio, la cookie [mySignedVisits] no tenía la firma correcta: se ignoró, como si faltara. Copiar la firma de otro valor (como la de [1], junto al valor [999]) tampoco funciona: la firma depende del valor. En cuanto al ID de sesión inventado, no corresponde a ninguna sesión existente: [Symfony] lo rechaza (este es el modo “estricto” de las sesiones de [PHP]) y crea una nueva sesión con un nuevo ID. Por lo tanto, el usuario no puede elegir la sesión de otro usuario.

Recordemos la regla: los datos provenientes del cliente solo son confiables si el servidor los ha protegido (firmados, como aquí o como con el token del capítulo sobre autenticación, o cifrados); los datos que no tienen nada que ocultar y cuyo valor el servidor verifica (el idioma del Ejemplo 22) pueden permanecer en texto plano. Una firma garantiza que un valor no ha sido alterado, pero no lo oculta: nunca debe confiarse un secreto al cliente, aunque esté firmado.