Formulários HTML e PHP

✓ Resposta: Dois detalhes que passam batido: mb_strlen em vez de strlen (senão "José" conta 5 caracteres) e o ! no createFromFormat junto com getLastErrors() — sem isso, 2026-02-31 é aceito e vira 3 de março silenciosamente.

<?php

declare(strict_types=1);

final class ValidadorCadastro
{
    public function __construct(private readonly PDO $pdo) {}

    /** @return array<string, string> campo => mensagem */
    public function validar(array $dados): array
    {
        $erros = [];

        // ---- nome: 2 a 100 caracteres ----
        $nome = trim((string) ($dados['nome'] ?? ''));

        // mb_strlen, não strlen: "José" tem 4 letras e 5 bytes.
        if (mb_strlen($nome) < 2 || mb_strlen($nome) > 100) {
            $erros['nome'] = 'O nome precisa ter entre 2 e 100 caracteres.';
        }

        // ---- e-mail: formato + unicidade ----
        $email = mb_strtolower(trim((string) ($dados['email'] ?? '')));

        if (!filter_var($email, FILTER_VALIDATE_EMAIL)) {
            $erros['email'] = 'Informe um e-mail válido.';
        } elseif ($this->emailJaExiste($email)) {
            $erros['email'] = 'Este e-mail já está cadastrado.';
        }

        // ---- senha: 8+, uma maiúscula, um número ----
        $senha = (string) ($dados['senha'] ?? '');

        if (mb_strlen($senha) < 8) {
            $erros['senha'] = 'A senha precisa de ao menos 8 caracteres.';
        } elseif (!preg_match('/[A-ZÀ-Þ]/u', $senha)) {
            $erros['senha'] = 'A senha precisa de ao menos uma letra maiúscula.';
        } elseif (!preg_match('/\d/', $senha)) {
            $erros['senha'] = 'A senha precisa de ao menos um número.';
        } elseif (isset($dados['senha_confirmacao'])
                  && !hash_equals($senha, (string) $dados['senha_confirmacao'])) {
            $erros['senha_confirmacao'] = 'As senhas não conferem.';
        }

        // ---- nascimento: maior de 18 ----
        $nascimento = (string) ($dados['nascimento'] ?? '');
        $data = \DateTimeImmutable::createFromFormat('!Y-m-d', $nascimento);

        // O `!` no formato zera hora/minuto/segundo; o getLastErrors pega
        // datas como 2026-02-31, que o createFromFormat aceitaria rolando
        // para março.
        if ($data === false || \DateTimeImmutable::getLastErrors()['warning_count'] > 0) {
            $erros['nascimento'] = 'Informe uma data válida.';
        } else {
            $idade = $data->diff(new \DateTimeImmutable('today'))->y;

            if ($data > new \DateTimeImmutable('today')) {
                $erros['nascimento'] = 'A data não pode estar no futuro.';
            } elseif ($idade < 18) {
                $erros['nascimento'] = 'É preciso ter 18 anos ou mais.';
            } elseif ($idade > 120) {
                $erros['nascimento'] = 'Confira a data de nascimento.';
            }
        }

        // ---- plano: lista branca ----
        if (!in_array($dados['plano'] ?? '', ['basico', 'pro'], true)) {
            $erros['plano'] = 'Escolha um plano.';
        }

        // ---- interesses: checkbox múltiplo ----
        $interesses = $dados['interesses'] ?? [];
        $validos = ['tecnologia', 'design', 'negocios', 'marketing'];

        if (!is_array($interesses) || $interesses === []) {
            $erros['interesses'] = 'Escolha ao menos um interesse.';
        } elseif (array_diff($interesses, $validos) !== []) {
            // Valor fora da lista = campo adulterado no cliente.
            $erros['interesses'] = 'Interesse inválido.';
        }

        return $erros;
    }

    private function emailJaExiste(string $email): bool
    {
        $stmt = $this->pdo->prepare('SELECT 1 FROM usuarios WHERE email = :e LIMIT 1');
        $stmt->execute([':e' => $email]);

        return $stmt->fetchColumn() !== false;
    }
}

✓ Resposta: Use 303, não 302: o 303 obriga o navegador a trocar para GET, enquanto no 302 alguns clientes mantêm o POST. E exit depois de header() é obrigatório — o PHP não para sozinho, e o código seguinte continuaria rodando.

<?php

declare(strict_types=1);

final class Flash
{
    private const CHAVE = '_flash';

    public static function definir(string $tipo, string $mensagem): void
    {
        $_SESSION[self::CHAVE][] = ['tipo' => $tipo, 'mensagem' => $mensagem];
    }

    public static function sucesso(string $m): void { self::definir('sucesso', $m); }
    public static function erro(string $m): void    { self::definir('erro', $m); }

    /** Lê E APAGA: por isso "flash" — aparece uma vez só. */
    public static function consumir(): array
    {
        $mensagens = $_SESSION[self::CHAVE] ?? [];

        unset($_SESSION[self::CHAVE]);

        return $mensagens;
    }
}

// ---------------------------------------- public/cadastro.php
declare(strict_types=1);

session_start();

require __DIR__ . '/../vendor/autoload.php';

// Só POST processa; GET apenas exibe.
if ($_SERVER['REQUEST_METHOD'] !== 'POST') {
    $erros = $_SESSION['_erros'] ?? [];
    $antigos = $_SESSION['_antigos'] ?? [];

    unset($_SESSION['_erros'], $_SESSION['_antigos']);

    require __DIR__ . '/../views/cadastro.php';
    exit;
}

$erros = (new ValidadorCadastro($pdo))->validar($_POST);

if ($erros !== []) {
    // Mesmo no erro, redireciona: assim o F5 não reenvia o POST.
    $_SESSION['_erros'] = $erros;

    // Devolve o que foi digitado, MENOS a senha.
    $_SESSION['_antigos'] = array_diff_key($_POST, array_flip(['senha', 'senha_confirmacao']));

    header('Location: /cadastro.php', true, 303);
    exit;
}

$stmt = $pdo->prepare(
    'INSERT INTO usuarios (nome, email, senha_hash, nascimento, plano, interesses)
     VALUES (:nome, :email, :senha, :nasc, :plano, :interesses)'
);

$stmt->execute([
    ':nome'  => trim($_POST['nome']),
    ':email' => mb_strtolower(trim($_POST['email'])),
    ':senha' => password_hash($_POST['senha'], PASSWORD_DEFAULT),
    ':nasc'  => $_POST['nascimento'],
    ':plano' => $_POST['plano'],
    ':interesses' => json_encode($_POST['interesses'], JSON_UNESCAPED_UNICODE),
]);

Flash::sucesso('Cadastro realizado! Confira seu e-mail para confirmar a conta.');

/**
 * O P-R-G: Post → Redirect → Get.
 *
 * Sem o redirect, a página de sucesso é a RESPOSTA do POST — e um F5 do
 * usuário reenvia o formulário, criando um cadastro duplicado. Com o 303,
 * o navegador troca para GET e o refresh apenas recarrega a confirmação.
 *
 * 303 (See Other) é o código correto aqui: o 302 deixa a critério do
 * navegador manter o método, e alguns mantêm o POST.
 */
header('Location: /cadastro-confirmado.php', true, 303);
exit;   // sempre exit depois de header(): o PHP continuaria executando

// ---------------------------------------- public/cadastro-confirmado.php
declare(strict_types=1);

session_start();

$mensagens = Flash::consumir();
?>
<!DOCTYPE html>
<html lang="pt-BR">
<head><meta charset="utf-8"><title>Cadastro confirmado</title></head>
<body>
    <?php foreach ($mensagens as $flash): ?>
        <div class="flash flash--<?= htmlspecialchars($flash['tipo'], ENT_QUOTES) ?>">
            <?= htmlspecialchars($flash['mensagem'], ENT_QUOTES, 'UTF-8') ?>
        </div>
    <?php endforeach; ?>

    <h1>Tudo certo!</h1>
    <p><a href="/login.php">Entrar na sua conta</a></p>
</body>
</html>

✓ Resposta: A regra é simples e não tem exceção: validação no cliente é conveniência, validação no servidor é segurança. O curl do comentário existe para deixar isso concreto — e repare que plano e interesses precisam de lista branca, ainda que na tela sejam radio e checkbox.

<?php
// views/cadastro.php — os atributos HTML5 melhoram a experiência,
// mas NÃO são validação: qualquer um remove com o DevTools ou manda
// a requisição direto com curl.
?>
<form method="post" action="/cadastro.php" novalidate>
    <input type="hidden" name="csrf" value="<?= htmlspecialchars($csrf, ENT_QUOTES) ?>">

    <label>Nome
        <input type="text" name="nome" required minlength="2" maxlength="100"
               value="<?= htmlspecialchars($antigos['nome'] ?? '', ENT_QUOTES) ?>"
               aria-describedby="erro-nome">
    </label>
    <?php if (isset($erros['nome'])): ?>
        <p id="erro-nome" class="erro"><?= htmlspecialchars($erros['nome'], ENT_QUOTES) ?></p>
    <?php endif; ?>

    <label>E-mail
        <input type="email" name="email" required maxlength="180"
               autocomplete="email"
               value="<?= htmlspecialchars($antigos['email'] ?? '', ENT_QUOTES) ?>">
    </label>

    <label>Senha
        <!-- O pattern é uma DICA. A regra de verdade está no PHP. -->
        <input type="password" name="senha" required minlength="8"
               pattern="(?=.*[A-Z])(?=.*\d).{8,}"
               autocomplete="new-password"
               title="Mínimo de 8 caracteres, com uma maiúscula e um número">
    </label>

    <label>Data de nascimento
        <input type="date" name="nascimento" required
               max="<?= (new DateTimeImmutable('-18 years'))->format('Y-m-d') ?>"
               value="<?= htmlspecialchars($antigos['nascimento'] ?? '', ENT_QUOTES) ?>">
    </label>

    <fieldset>
        <legend>Plano</legend>
        <?php foreach (['basico' => 'Básico', 'pro' => 'Pro'] as $valor => $rotulo): ?>
            <label>
                <input type="radio" name="plano" value="<?= $valor ?>" required
                    <?= ($antigos['plano'] ?? '') === $valor ? 'checked' : '' ?>>
                <?= $rotulo ?>
            </label>
        <?php endforeach; ?>
    </fieldset>

    <fieldset>
        <legend>Interesses</legend>
        <?php foreach (['tecnologia' => 'Tecnologia', 'design' => 'Design',
                        'negocios' => 'Negócios', 'marketing' => 'Marketing'] as $v => $r): ?>
            <label>
                <!-- Os colchetes fazem o PHP receber um array -->
                <input type="checkbox" name="interesses[]" value="<?= $v ?>"
                    <?= in_array($v, $antigos['interesses'] ?? [], true) ? 'checked' : '' ?>>
                <?= $r ?>
            </label>
        <?php endforeach; ?>
    </fieldset>

    <button type="submit">Criar conta</button>
</form>

<?php
// (o strict_types não entra aqui: numa view que já emitiu HTML, ele seria
//  erro fatal — `declare` tem de ser a primeira instrução do arquivo.
//  Este bloco pertence ao controller, em arquivo próprio.)

/**
 * A DEMONSTRAÇÃO de por que o servidor revalida tudo.
 *
 * Qualquer uma destas requisições ignora 100% da validação HTML5 —
 * e chega no PHP exatamente como uma vinda do formulário:
 *
 *   curl -X POST https://site.com/cadastro.php \
 *        -d "nome=x" -d "email=nao-eh-email" -d "senha=123" \
 *        -d "nascimento=2020-01-01" -d "plano=gratuito_hackeado" \
 *        -d "interesses[]=<script>alert(1)</script>"
 *
 * O `plano` fora da lista branca e o interesse com script mostram por que
 * não basta validar formato: valor de radio e checkbox É entrada do
 * usuário, mesmo tendo vindo de uma lista fechada na tela.
 */
final class ProcessadorCadastro
{
    public function __construct(
        private readonly ValidadorCadastro $validador,
        private readonly PDO $pdo,
    ) {}

    public function processar(array $post, string $csrfEsperado): array
    {
        // 1) CSRF antes de tudo.
        if (!hash_equals($csrfEsperado, (string) ($post['csrf'] ?? ''))) {
            return ['erros' => ['_' => 'Sessão expirada. Recarregue a página.']];
        }

        // 2) A MESMA validação, independente do que o cliente disse.
        $erros = $this->validador->validar($post);

        if ($erros !== []) {
            return ['erros' => $erros];
        }

        // 3) Só aqui os dados são considerados confiáveis.
        return ['id' => $this->inserir($post)];
    }

    private function inserir(array $post): int
    {
        $stmt = $this->pdo->prepare(
            'INSERT INTO usuarios (nome, email, senha_hash, nascimento, plano, interesses)
             VALUES (:nome, :email, :senha, :nasc, :plano, :int)'
        );

        $stmt->execute([
            ':nome'  => trim($post['nome']),
            ':email' => mb_strtolower(trim($post['email'])),
            ':senha' => password_hash($post['senha'], PASSWORD_DEFAULT),
            ':nasc'  => $post['nascimento'],
            ':plano' => $post['plano'],
            ':int'   => json_encode($post['interesses'], JSON_UNESCAPED_UNICODE),
        ]);

        return (int) $this->pdo->lastInsertId();
    }
}

✓ Resposta: Duas decisões que fazem diferença: registrar a tentativa antes de processar (senão envios inválidos não contam e o limite não protege de nada) e guardar o IP com hash_hmac — endereço IP é dado pessoal, e o hash permite contar sem armazená-lo em claro.

<?php

declare(strict_types=1);

interface LimitadorEnvioInterface
{
    /** @return array{permitido: bool, restantes: int, retry_after: int} */
    public function verificar(string $ip): array;

    public function registrar(string $ip): void;
}

/** Versão em banco: funciona com múltiplos servidores. */
final class LimitadorEnvioBanco implements LimitadorEnvioInterface
{
    // CREATE TABLE envios_formulario (
    //     id        BIGINT UNSIGNED AUTO_INCREMENT PRIMARY KEY,
    //     ip_hash   CHAR(64)  NOT NULL,
    //     enviado_em DATETIME NOT NULL,
    //     INDEX idx_envios (ip_hash, enviado_em)
    // ) ENGINE=InnoDB;

    public function __construct(
        private readonly PDO $pdo,
        private readonly int $maximo = 3,
        private readonly int $janelaSegundos = 300,
    ) {}

    public function verificar(string $ip): array
    {
        $stmt = $this->pdo->prepare(
            'SELECT COUNT(*) AS total, MIN(enviado_em) AS primeiro
               FROM envios_formulario
              WHERE ip_hash = :ip
                AND enviado_em > DATE_SUB(NOW(), INTERVAL :janela SECOND)'
        );
        $stmt->bindValue(':ip', $this->hash($ip));
        $stmt->bindValue(':janela', $this->janelaSegundos, PDO::PARAM_INT);
        $stmt->execute();

        $linha = $stmt->fetch(PDO::FETCH_ASSOC);
        $total = (int) $linha['total'];

        if ($total < $this->maximo) {
            return ['permitido' => true, 'restantes' => $this->maximo - $total, 'retry_after' => 0];
        }

        $libera = strtotime($linha['primeiro']) + $this->janelaSegundos;

        return [
            'permitido'   => false,
            'restantes'   => 0,
            'retry_after' => max(1, $libera - time()),
        ];
    }

    public function registrar(string $ip): void
    {
        $this->pdo->prepare(
            'INSERT INTO envios_formulario (ip_hash, enviado_em) VALUES (:ip, NOW())'
        )->execute([':ip' => $this->hash($ip)]);
    }

    public function limpar(): int
    {
        $stmt = $this->pdo->prepare(
            'DELETE FROM envios_formulario
              WHERE enviado_em < DATE_SUB(NOW(), INTERVAL :janela SECOND)'
        );
        $stmt->bindValue(':janela', $this->janelaSegundos * 2, PDO::PARAM_INT);
        $stmt->execute();

        return $stmt->rowCount();
    }

    /**
     * IP é dado pessoal (LGPD/GDPR). Guardar o hash com um sal da aplicação
     * permite contar sem armazenar o endereço em texto puro.
     */
    private function hash(string $ip): string
    {
        return hash_hmac('sha256', $ip, $_ENV['APP_KEY'] ?? 'troque-esta-chave');
    }
}

/** Versão em arquivo: para hospedagem sem banco disponível. */
final class LimitadorEnvioArquivo implements LimitadorEnvioInterface
{
    public function __construct(
        private readonly string $diretorio = '/tmp/form-limits',
        private readonly int $maximo = 3,
        private readonly int $janelaSegundos = 300,
    ) {
        if (!is_dir($this->diretorio)) {
            mkdir($this->diretorio, 0700, true);
        }
    }

    public function verificar(string $ip): array
    {
        $registros = $this->ler($ip);

        if (count($registros) < $this->maximo) {
            return ['permitido' => true,
                    'restantes' => $this->maximo - count($registros), 'retry_after' => 0];
        }

        return ['permitido' => false, 'restantes' => 0,
                'retry_after' => max(1, min($registros) + $this->janelaSegundos - time())];
    }

    public function registrar(string $ip): void
    {
        $arquivo = $this->arquivoDe($ip);
        $handle = fopen($arquivo, 'c+');

        // Sem LOCK_EX, dois envios simultâneos leem o mesmo contador e um
        // sobrescreve o outro — o limite passa a ser furável na corrida.
        flock($handle, LOCK_EX);

        $conteudo = stream_get_contents($handle);
        $registros = $conteudo ? (json_decode($conteudo, true) ?: []) : [];

        $registros = array_values(array_filter(
            $registros, fn(int $t): bool => $t > time() - $this->janelaSegundos
        ));

        $registros[] = time();

        ftruncate($handle, 0);
        rewind($handle);
        fwrite($handle, json_encode($registros));

        flock($handle, LOCK_UN);
        fclose($handle);
    }

    private function ler(string $ip): array
    {
        $arquivo = $this->arquivoDe($ip);

        if (!is_file($arquivo)) {
            return [];
        }

        $registros = json_decode((string) file_get_contents($arquivo), true) ?: [];

        return array_values(array_filter(
            $registros, fn(int $t): bool => $t > time() - $this->janelaSegundos
        ));
    }

    private function arquivoDe(string $ip): string
    {
        return $this->diretorio . '/' . sha1($ip) . '.json';
    }
}

// ---------------------------------------- no processamento do formulário
declare(strict_types=1);

session_start();

function ipDoCliente(): string
{
    // Só confie em X-Forwarded-For se a aplicação estiver atrás de um proxy
    // SEU — o cliente pode forjar o header e trocar de "IP" a cada envio.
    $atrasDeProxy = ($_ENV['ATRAS_DE_PROXY'] ?? 'false') === 'true';

    if ($atrasDeProxy && !empty($_SERVER['HTTP_X_FORWARDED_FOR'])) {
        return trim(explode(',', $_SERVER['HTTP_X_FORWARDED_FOR'])[0]);
    }

    return $_SERVER['REMOTE_ADDR'] ?? '0.0.0.0';
}

$limitador = new LimitadorEnvioBanco($pdo, maximo: 3, janelaSegundos: 300);

$ip = ipDoCliente();
$situacao = $limitador->verificar($ip);

if (!$situacao['permitido']) {
    http_response_code(429);
    header('Retry-After: ' . $situacao['retry_after']);

    $minutos = (int) ceil($situacao['retry_after'] / 60);

    Flash::erro("Muitos envios seguidos. Tente novamente em {$minutos} minuto(s).");

    header('Location: /cadastro.php', true, 303);
    exit;
}

// Registra ANTES de processar: se o processamento falhar, a tentativa
// ainda conta — senão um atacante fica livre mandando dados inválidos.
$limitador->registrar($ip);

$erros = (new ValidadorCadastro($pdo))->validar($_POST);

✓ Resposta: São dois comportamentos silenciosos, e nenhum dos dois gera erro na tela. O primeiro é a troca de nomes: ponto, espaço e colchete não fechado viram _, então <input name="perfil.nome"> chega como $_POST['perfil_nome'] — e quem procura pela chave original recebe string vazia do ?? '', que a validação acusa como "campo obrigatório" num campo que o usuário preencheu. A herança vem do tempo em que cada campo virava uma variável do PHP, e nome de variável não aceita ponto. O segundo é o max_input_vars, que vale 1000 por padrão: um formulário maior que isso não falha — o excedente é simplesmente descartado, e o $_POST que o seu código recebe não tem como saber que foi cortado. É o tipo de defeito que aparece só no cliente com a planilha grande. Contar os campos do corpo bruto antes de confiar custa uma linha e evita a investigação inteira.

<?php
declare(strict_types=1);

// ── 1. O PHP renomeia campos antes de você ver ────────────────────────
// Ponto, espaço e colchete não fechado viram "_" no nome da chave.
$enviadoPeloNavegador = 'perfil.nome=Ana&data nascimento=1990-05-02&a[b=x&normal=ok';
parse_str($enviadoPeloNavegador, $recebido);

foreach ($recebido as $chave => $valor) {
    echo "  chegou como \$_POST['{$chave}']\n";
}
// perfil_nome, data_nascimento, a_b, normal — três dos quatro trocados.
// Por isso um <input name="perfil.nome"> nunca é encontrado por
// $_POST['perfil.nome']: a chave não existe, e o ?? '' devolve string
// vazia, que a validação acusa como "campo obrigatório".

// ── 2. Diagnóstico: confira se o que chegou é o que você espera ───────
function camposInesperados(array $recebidos, array $esperados): array
{
    return [
        'faltando' => array_values(array_diff($esperados, array_keys($recebidos))),
        'a_mais'   => array_values(array_diff(array_keys($recebidos), $esperados)),
    ];
}

$esperados = ['perfil.nome', 'data nascimento', 'normal'];
print_r(camposInesperados($recebido, $esperados));

// ── 3. O limite silencioso: max_input_vars ────────────────────────────
// O padrão é 1000. Um formulário com mais campos que isso NÃO falha:
// o PHP descarta o excedente e segue em frente.
$limite = (int) ini_get('max_input_vars');
echo "  max_input_vars = {$limite}\n";

$grande = implode('&', array_map(fn(int $i) => "item[{$i}]=v{$i}", range(0, 1200)));
@parse_str($grande, $truncado);
$quantos = count($truncado['item'] ?? []);
echo "  enviados 1201 campos, recebidos {$quantos}\n";

// A defesa é contar antes de confiar. Em requisição real, o que se conta
// é o corpo bruto — $_POST já vem truncado e não sabe disso.
function corpoFoiTruncado(string $corpoBruto): bool
{
    return substr_count($corpoBruto, '&') + 1 > (int) ini_get('max_input_vars');
}

echo '  corpoFoiTruncado(): ' . var_export(corpoFoiTruncado($grande), true) . "\n";