Skip to content

6. Escopos de dados

Uma aplicação web atende muitos usuários ao mesmo tempo, e cada usuário faz numerosas requisições. Os dados podem, portanto, ser compartilhados em vários níveis, conhecidos como seu escopo:

  • Escopo de aplicação: os dados são compartilhados por todos os usuários durante todo o tempo de vida da aplicação (a lista de médicos, por exemplo);
  • Escopo de requisição: os dados existem apenas durante o processamento de uma requisição (o modelo de uma view, o usuário logado conforme identificado para essa requisição);
  • Escopo de sessão: os dados são específicos de um usuário e devem persistir de uma requisição para a seguinte (o idioma selecionado, um carrinho de compras);
  • Escopo de cliente: dados armazenados no próprio navegador, em um cookie.

Em [PHP], esses escopos se comportam de maneira particular porque a aplicação é reconstruída a cada requisição (Exemplo 01): nada sobrevive na memória de uma requisição para a seguinte. Todo dado que precise durar mais que uma única requisição é, portanto, armazenado fora do [PHP]: no cache, em um banco de dados, em arquivos ou do lado do cliente. Esta é a chamada arquitetura “shared-nothing”: cada requisição é processada isoladamente por um processo que não compartilha nada com os que processam as demais requisições. Essa abordagem tem vantagens significativas: um erro afeta apenas uma única requisição, nenhum dado vaza de um usuário para outro, e vários servidores idênticos podem ser executados atrás de um balanceador de carga, desde que compartilhem o mesmo cache e o mesmo banco de dados.

No [Symfony], cada escopo tem seu próprio contêiner:

Escopo
Contêiner
Duração
aplicação
o cache (serviço [cache.app], exemplo 20) ou o banco de dados
a duração escolhida, ou ilimitada
Requisição
os serviços do contêiner (um objeto por classe, durante a requisição), os atributos da requisição (exemplo 12)
o processamento de uma requisição
sessão
a sessão ([$request->getSession()], Exemplo 20), mantida pelo servidor e recuperada por meio de um cookie
por padrão, até o navegador ser fechado e, no máximo, pela duração da sessão do [PHP] (24 minutos de inatividade por padrão)
cliente
um cookie ([Cookie::create], exemplo 22), em texto simples
O tempo de expiração do cookie

A sessão do [Symfony] é uma sessão do lado do servidor, como as do [Java] ([JSESSIONID]) ou as do [PHP] padrão, de quem, aliás, ela toma emprestados o mecanismo e o cookie ([PHPSESSID]): seus dados são armazenados no servidor (um arquivo por sessão, com a configuração usada em nossos exemplos), e o navegador guarda apenas o identificador, um número aleatório impossível de adivinhar. Isso difere do [Flask], cuja sessão inteira é armazenada em um cookie assinado do lado do cliente.

6.1. Exemplo 23: Escopos

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

O arquivo [config/packages/framework.yaml] configura a sessão e os locks, como no Exemplo 20.

6.1.1. Os objetos: src/Service/CounterService.php e RequestInfo.php

<?php
// src/Service/CounterService.php: escopo de APLICAÇÃO, contadores compartilhados por
// todas as requisições de todos os usuários, armazenados no cache (veja o exemplo 20)

namespace App\Service;

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

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

    // mais um número sob a chave [$key]; o cache "file" não incrementa um
    // número de forma atômica: um lock protege a leitura e a escrita
    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');
    }
}
  • linhas 12–16: o serviço recebe o cache da aplicação e a fábrica de locks (Exemplo 20);
  • linhas 20–32: um contador de escopo de aplicação: um número armazenado no cache sob uma chave e incrementado em 1 a cada chamada. O cache “de arquivos” de nossos exemplos não oferece suporte a operações de incremento atômicas: o valor deve ser lido, incrementado e depois gravado, e duas requisições concorrentes poderiam ler o mesmo valor, resultando em um acesso perdido. Um lock, um por chave, protege, portanto, tanto a leitura quanto a gravação; o bloco [finally] o libera em todos os casos, mesmo após o [return] da linha 28;
  • linhas 34–37: o contador de visitas.
<?php
// src/Service/RequestInfo.php: escopo de REQUISIÇÃO, as informações de uma requisição

namespace App\Service;

use DateTimeImmutable;

class RequestInfo
{
    public readonly int $number;

    public readonly string $start;

    // o contêiner cria UM objeto desta classe, no primeiro pedido, e
    // depois o devolve a todos que o pedirem durante a requisição
    public function __construct(CounterService $counter)
    {
        // um número por OBJETO criado, tirado de um contador compartilhado por todas as requisições
        $this->number = $counter->next('instances');
        // a hora, com seus milissegundos (v)
        $this->start = (new DateTimeImmutable())->format('H:i:s.v');
    }
}
  • linhas 10–12: propriedades declaradas como [readonly] uma a uma (em vez da classe inteira): elas só podem ser atribuídas uma vez, pelo construtor;
  • linhas 16–22: informações de escopo de requisição: um número, derivado de um contador compartilhado por todas as requisições (o serviço anterior, sob outra chave), e o horário da requisição, incluindo milissegundos (formato [v]). O construtor recebe o [CounterService] do contêiner: um serviço pode solicitar outro serviço, assim como uma ação.

Nenhuma configuração é necessária: por padrão, um serviço no contêiner é compartilhado (shared). O contêiner cria o objeto na primeira solicitação e depois devolve o mesmo a todas as solicitações seguintes. No modo [PHP] padrão, o contêiner é reconstruído a cada requisição: um serviço compartilhado é, portanto, um objeto de escopo de requisição. (Também é possível solicitar um novo objeto a cada injeção usando a opção [shared: false] no arquivo [services.yaml].) Surge uma nuance com servidores de aplicação que mantêm a aplicação em memória de uma requisição para a seguinte para melhorar o desempenho, como o modo worker do [FrankenPHP]: nesse caso, um serviço é compartilhado por todas as requisições tratadas pelo processo. [Symfony] então redefine, entre as requisições, os serviços que implementam a interface [ResetInterface]; cabe a esses serviços garantir que nada seja retido de uma requisição para a seguinte.

6.1.2. Uma variável global para as views: config/packages/twig.yaml

1
2
3
4
5
6
7
# config/packages/twig.yaml: a configuração do TwigBundle
twig:
    default_path: '%kernel.project_dir%/templates'
    # uma variável GLOBAL das views, que é um SERVIÇO (o @ designa um serviço):
    # o objeto RequestInfo da requisição atual
    globals:
        info: '@App\Service\RequestInfo'
  • Linhas 6–7: uma variável global nas views (Exemplo 15) pode ser um serviço: o nome de sua classe, precedido de [@]. Todas as views têm, assim, acesso à variável [info], que é o objeto [RequestInfo] da requisição atual. O [Twig] não tem equivalente à diretiva [@inject] do [Blade]: uma view não solicita nada ao contêiner; ela recebe o que lhe é dado.

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

Um cookie é um dado confiado ao cliente, que pode lê-lo e modificá-lo. O [Laravel] criptografa seus cookies; o [Symfony] não. Para que um cookie seja confiável, porém, basta que ele seja assinado: seu valor é transmitido em texto simples, mas é seguido de uma assinatura que somente o servidor sabe calcular, pois depende de uma chave secreta. Um valor modificado pelo cliente deixa de ter a assinatura correta, e o servidor o rejeita.

<?php
// src/Service/SignedCookies.php: cookies ASSINADOS. O valor viaja em texto claro,
// seguido de uma assinatura que somente o servidor sabe calcular: um valor modificado
// pelo cliente deixa de ter a assinatura correta e é recusado

namespace App\Service;

use Symfony\Component\DependencyInjection\Attribute\Autowire;

class SignedCookies
{
    // a chave da assinatura: o segredo da aplicação (APP_SECRET, arquivo .env)
    public function __construct(#[Autowire('%kernel.secret%')] private string $secret)
    {
    }

    // "5" -> "5.3f1c...": o valor, um ponto, a assinatura (HMAC-SHA256 do valor)
    public function sign(string $value): string
    {
        return $value.'.'.hash_hmac('sha256', $value, $this->secret);
    }

    // o valor se a assinatura estiver correta, null caso contrário
    public function verify(?string $cookie): ?string
    {
        if ($cookie === null || ! str_contains($cookie, '.')) {
            return null;
        }
        // strrpos: a posição do ÚLTIMO ponto
        $value = substr($cookie, 0, strrpos($cookie, '.'));
        // hash_equals compara duas strings em tempo constante, o que não revela
        // a um atacante quantos caracteres estão certos
        return hash_equals($this->sign($value), $cookie) ? $value : null;
    }
}
  • linha 13: a chave de assinatura é o segredo da aplicação, a variável [APP_SECRET] do arquivo [.env] (Exemplo 01), que o contêiner reconhece como o parâmetro [kernel.secret]. Um parâmetro não é um objeto: o atributo [#[Autowire]] informa ao contêiner o valor a fornecer, em que [%name%] se refere a um parâmetro;
  • linhas 18–21: a assinatura é um HMAC (Hash-based Message Authentication Code): o hash SHA-256 do valor, calculado com a chave secreta e escrito em hexadecimal. O cookie contém o valor, um ponto e, em seguida, a assinatura;
  • Linhas 24–34: o processo de verificação recalcula a assinatura do valor recebido e a compara com a do cookie. [hash_equals] compara duas strings em um tempo que não depende do número de caracteres idênticos: uma comparação comum pararia no primeiro caractere diferente, e um atacante poderia, medindo o tempo de resposta, adivinhar a assinatura caractere por caractere.

Este é o princípio do token JWT, que o próximo capítulo usará para a autenticação.

6.1.4. O controller: src/Controller/ScopesController.php

<?php
// src/Controller/ScopesController.php: os quatro escopos de dados

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
{
    // os serviços são fornecidos pelo contêiner (veja o exemplo 06)
    #[Route('/', name: 'scopes', methods: ['GET'])]
    public function display(Request $request, CounterService $counter, RequestInfo $info,
        SignedCookies $cookies): Response
    {
        // APLICAÇÃO: o contador compartilhado
        $total = $counter->increment();
        // SESSÃO: dados específicos DESTE navegador, mantidos pelo SERVIDOR
        // (um arquivo de var/sessions), reencontrados graças ao cookie de sessão
        $session = $request->getSession();
        $session->set('visits', $session->get('visits', 0) + 1);
        // CLIENTE: dados mantidos pelo NAVEGADOR em cookies,
        // reenviados ao servidor a cada requisição; um em texto claro, o outro assinado
        $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;
    }
}
  • linhas 19–20: a ação recebe a requisição e três serviços fornecidos pelo contêiner;
  • linha 23: o escopo de aplicação;
  • linhas 26–27: o escopo de sessão. [$request->getSession()] devolve a sessão do usuário; [get(key, default)] lê um valor, e [set(key, value)] o grava. [Symfony] salva a sessão ao final da requisição;
  • Linhas 30–31: o escopo de cliente, com dois cookies. Seus valores são strings fornecidas pelo navegador e podem, portanto, estar ausentes ou ser inválidos: a conversão [(int)] devolve 0 para [null] ou para um texto que não seja um número. O valor do cookie assinado só é aceito se sua assinatura estiver correta;
  • linhas 32–39: para definir um cookie, é necessário o objeto de resposta: [render] o constrói (exemplo 13), e depois [setCookie] adiciona os cookies a ele. Sem data de expiração, um cookie dura até o navegador ser fechado (é um cookie de “sessão”, segundo a definição dos navegadores).

6.1.5. A view: 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: a variável global de config/packages/twig.yaml, um serviço; durante
       a MESMA requisição, é o mesmo objeto que o da action #}
    <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: a sessão, também acessível nas views #}
      <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>
  • linha 16: [info], a variável global: durante a mesma requisição, é o mesmo objeto [RequestInfo] que o da ação; a view exibe seu número, que deve ser o recebido da ação;
  • linha 19: a sessão também é acessível nas views por meio da variável [app.session].

6.1.6. Execução

Após algumas visitas em um navegador:

Image

Vamos acompanhar as requisições com o [curl], que age como um primeiro navegador armazenando seus cookies no arquivo [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>
...

A resposta define três cookies. O primeiro, [myVisits], contém o valor em texto simples. O segundo, [mySignedVisits], contém o mesmo valor, seguido de um ponto e de sua assinatura. O terceiro, [PHPSESSID], é o ID da sessão. Os dados da sessão são armazenados em um arquivo no servidor, [var/sessions/dev/sess_32da14307b05da3847ea54b2ae3e6f77], cujo nome corresponde ao ID da sessão:

_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;}

No formato de serialização do [PHP], vemos um array com uma única chave, [visits], e um valor inteiro 1 ([i:1]), seguido de informações do [Symfony] sobre a sessão (datas de criação e de último uso). Uma segunda visita, com os mesmos 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>
...

A sessão já existe: o cookie [PHPSESSID] não é reenviado. Um segundo “navegador”, com seu próprio arquivo de cookies, inicialmente vazio:

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>

O contador da aplicação continuou; a sessão e os cookies do segundo navegador recomeçam em 1. Cada requisição teve seu próprio objeto [RequestInfo], e em cada uma delas a ação e a view viram o mesmo. Por fim, um usuário malicioso forja seus próprios cookies: 1.000 visitas em [myVisits], 999 em [mySignedVisits] (com uma assinatura fabricada) e um ID de sessão de sua própria invenção:

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>

O cookie em texto simples foi aceito tal como estava: 1.001 visitas. O cookie [mySignedVisits], porém, não tinha a assinatura correta: foi ignorado, como se estivesse ausente. Copiar a assinatura de outro valor (como a de [1], ao lado do valor [999]) também não funciona: a assinatura depende do valor. Quanto ao ID de sessão inventado, ele não corresponde a nenhuma sessão existente: o [Symfony] o rejeita (é o modo “strict” das sessões do [PHP]) e cria uma nova sessão com um novo ID. O usuário não pode, portanto, escolher a sessão de outro usuário.

Guardemos a regra: os dados vindos do cliente só são confiáveis se forem protegidos pelo servidor (assinados, como aqui ou como no token do capítulo sobre autenticação, ou criptografados); dados que não têm nada a esconder e cujo valor é verificado pelo servidor (o idioma no Exemplo 22) podem permanecer em texto simples. Uma assinatura garante que um valor não foi alterado, mas não o oculta: um segredo nunca deve ser confiado ao cliente, mesmo que assinado.