: // echo platform_captcha_field('registo', $pdo); // // // no handler, depois do CSRF: // if (($erro = platform_captcha_verify('registo', $pdo)) !== null) { // $error = $erro; // já em português, pronto a mostrar // } // // O primeiro argumento é o âmbito: entra na assinatura, para que um desafio // colhido no formulário de contacto não sirva no de registo. Dois formulários na // mesma página com âmbitos diferentes são independentes. // // API pública: // platform_captcha_config(?array) — configuração do módulo // platform_captcha_field(string, ?PDO) — o bloco HTML pronto a imprimir // platform_captcha_issue(string, ?PDO) — pergunta + token, para marcação própria // platform_captcha_verify(string, ?PDO) — null passa, ou a mensagem de erro // platform_captcha_ok(string, ?PDO) — o mesmo em booleano // // E o recurso — a razão pela qual este módulo existe. Ver a secção no fim: // platform_captcha_appeal_offer(PDO, form, reason) — guarda a submissão recusada // platform_captcha_appeal_field(token, form, ?PDO) — o bloco do segundo ecrã // platform_captcha_appeal_claim(PDO, form, &$error) — devolve a submissão libertada require_once __DIR__ . '/functions_settings.php'; require_once __DIR__ . '/functions_client_ip.php'; /** * Configuração. Com um array define; sem argumentos, lê. */ function platform_captcha_config(?array $set = null): array { static $cfg = [ // 'math' (contas), 'letter' (letra de uma palavra) ou 'mixed' (sorteia // uma das duas por desafio). Misturar é de graça e obriga quem // automatiza a resolver dois formatos em vez de um. 'type' => 'mixed', // Validade do desafio. Curta de propósito: sem sessão activa é ela que // limita quantas respostas cabem num token. 15 minutos chegam para // preencher um formulário e não chegam para um ataque com paciência. 'ttl' => 900, // Nomes dos campos. Configuráveis porque um site pode já ter um campo // chamado 'captcha' vindo de outra coisa. 'field_answer' => 'captcha_answer', 'field_token' => 'captcha_token', // Classes do Bootstrap 5, que é o que toda a frota carrega. Um sítio sem // Bootstrap passa strings vazias e estiliza por fora. 'class_wrap' => 'mb-3', 'class_label' => 'form-label', 'class_input' => 'form-control', 'class_help' => 'form-text', 'help' => 'Uma pergunta simples, para travar envios automáticos.', 'autocomplete' => 'off', // Uma tentativa por pergunta, quando há sessão. Ver o cabeçalho. 'single_use' => true, // Um token forjado ou em falta é sinal de bot e conta para a escalada do // functions_ip_ban.php. Uma resposta errada NÃO conta, e a diferença é // deliberada: a escada bane aos 3 registos em 24 h, e quem se engana // duas vezes a escrever "catorze" não é um bot — seria banir gente por // errar uma pergunta que nós próprios lhe fizemos. 'offence_forged' => true, 'offence_wrong' => false, // ─── O recurso ────────────────────────────────────────────────────── // Tabela própria, criada à cabeça como as do functions_ip_ban.php: a // `blocked_submissions` tem forma diferente em cada site e é um registo, // não uma fila de trabalho. 'appeal_table' => 'captcha_appeals', // Duas horas para responder. É uma pessoa a olhar para o ecrã, não um // formulário deixado aberto — e quanto mais curto, menos tempo a // submissão recusada fica guardada. 'appeal_ttl' => 7200, // Tentativas por recurso, e recursos por IP à hora. O primeiro impede // que se esgotem as respostas possíveis numa só submissão retida; o // segundo impede que a fila de recursos vire um depósito de spam. 'appeal_tries' => 6, 'appeal_max_ip' => 5, // Motivos que NÃO dão direito a recurso. A recusa silenciosa existe // para o bot não ficar a saber o que o apanhou, e estes dois não têm // leitura inocente: o honeypot é um campo que ninguém vê, e o carimbo só // é produzido pelo nosso próprio formulário. Oferecer recurso a quem // falha ali é ensiná-lo a contornar. Todos os outros — país, limite por // IP, pontuação de conteúdo, formulário expirado — têm falsos positivos // reais e é para eles que isto serve. 'appeal_never' => ['honeypot', 'carimbo inválido'], // Palavras do desafio da letra. Sem acentos, de propósito: a resposta é // uma letra e não vale a pena pôr ninguém a decidir se escreve "a" ou // "á". 'words' => [ 'CADEIRA', 'JANELA', 'SAPATO', 'CAMINHO', 'MERCADO', 'PALAVRA', 'LARANJA', 'MONTANHA', 'TELEFONE', 'BICICLETA', 'ESCADA', 'FLORESTA', 'CAMISOLA', 'GUITARRA', 'PADEIRO', 'CADERNO', ], ]; if ($set !== null) { $cfg = array_merge($cfg, $set); } return $cfg; } /** * A chave que assina os desafios. * * Domínio próprio: um carimbo do anti-spam não valida aqui, nem ao contrário. A * derivação e os seus três degraus estão em functions_settings.php, que é onde * vive a única implementação. */ function platform_captcha_key(?PDO $pdo = null): string { return platform_derived_key('captcha', $pdo); } /** * A pergunta e a resposta, derivadas do nonce. * * Determinista: o mesmo nonce, com a mesma chave e o mesmo âmbito, dá sempre o * mesmo par. É isso que dispensa guardar seja o que for — o servidor volta a * calcular a resposta no pedido seguinte em vez de se lembrar dela. * * Note-se que a resposta nunca vai para o cliente, nem sequer como hash: um hash * de "14" quebra-se com vinte tentativas numa consola. * * @return array{question:string, answer:string} */ function platform_captcha_challenge(string $form, string $nonce, ?PDO $pdo = null): array { $cfg = platform_captcha_config(); $b = array_values(unpack( 'C*', hash_hmac('sha256', 'q|' . $form . '|' . $nonce, platform_captcha_key($pdo), true) )); $type = $cfg['type']; if ($type === 'mixed') { $type = ($b[0] % 2 === 0) ? 'math' : 'letter'; } if ($type === 'letter') { $words = array_values($cfg['words']); $word = $words ? $words[$b[1] % count($words)] : 'CADEIRA'; // Até à quinta letra, e nunca além do tamanho da palavra. $max = min(5, mb_strlen($word, 'UTF-8')); $pos = 1 + ($b[2] % $max); $ord = [1 => 'primeira', 2 => 'segunda', 3 => 'terceira', 4 => 'quarta', 5 => 'quinta'][$pos]; return [ 'question' => 'Escreva a ' . $ord . ' letra da palavra ' . $word . '.', 'answer' => mb_substr($word, $pos - 1, 1, 'UTF-8'), ]; } // Contas. Os limites dos operandos mantêm o resultado entre 0 e 20, que é o // intervalo que platform_captcha_number_words() sabe escrever por extenso. switch ($b[1] % 3) { case 0: $x = 1 + ($b[2] % 9); $y = 1 + ($b[3] % 9); $op = 'mais'; $r = $x + $y; break; case 1: // O maior primeiro: um resultado negativo é uma pergunta injusta. $x = 2 + ($b[2] % 8); $y = 1 + ($b[3] % ($x - 1)); $op = 'menos'; $r = $x - $y; break; default: $x = 2 + ($b[2] % 4); $y = 2 + ($b[3] % 3); $op = 'vezes'; $r = $x * $y; } // Um operando por extenso e o outro em algarismos, sorteados. Custa nada e // parte o regex /(\d+)\s*\+\s*(\d+)/ com que se resolve um captcha destes em // três linhas. $words = platform_captcha_number_words(); $left = ($b[4] % 2 === 0) ? (string) $x : $words[$x]; $right = ($b[4] % 2 === 0) ? $words[$y] : (string) $y; // "duas vezes três", não "dois vezes três": quem conta ali são as vezes, e // "vez" é feminino. Só acontece com o operando da esquerda de uma // multiplicação, e só quando calha ser escrito por extenso. A resposta não // muda com isto — platform_captcha_canonical_answer() já lê "duas" como 2. if ($op === 'vezes' && $left === 'dois') { $left = 'duas'; } return [ 'question' => 'Quanto é ' . $left . ' ' . $op . ' ' . $right . '?', 'answer' => (string) $r, ]; } /** 0–20 por extenso, já na forma normalizada (minúsculas, sem acentos). */ function platform_captcha_number_words(): array { return [ 0 => 'zero', 'um', 'dois', 'tres', 'quatro', 'cinco', 'seis', 'sete', 'oito', 'nove', 'dez', 'onze', 'doze', 'treze', 'catorze', 'quinze', 'dezasseis', 'dezassete', 'dezoito', 'dezanove', 'vinte', ]; } /** * Normaliza uma resposta: minúsculas, sem acentos, sem nada que não seja letra * ou algarismo. "Catorze", "catorze " e "CATORZE" são a mesma resposta. */ function platform_captcha_normalize(string $s): string { $s = mb_strtolower(trim($s), 'UTF-8'); $s = strtr($s, [ 'á' => 'a', 'à' => 'a', 'â' => 'a', 'ã' => 'a', 'ä' => 'a', 'é' => 'e', 'è' => 'e', 'ê' => 'e', 'í' => 'i', 'ì' => 'i', 'î' => 'i', 'ó' => 'o', 'ò' => 'o', 'ô' => 'o', 'õ' => 'o', 'ö' => 'o', 'ú' => 'u', 'ù' => 'u', 'û' => 'u', 'ü' => 'u', 'ç' => 'c', 'ñ' => 'n', ]); return (string) preg_replace('/[^a-z0-9]+/', '', $s); } /** * A resposta de quem preencheu, posta na mesma forma que a nossa: por extenso * vira algarismos, e as variantes do Brasil são aceites porque quem as escreve * respondeu certo. */ function platform_captcha_canonical_answer(string $raw): string { $n = platform_captcha_normalize($raw); $alias = [ 'uma' => 'um', 'duas' => 'dois', 'quatorze' => 'catorze', 'dezesseis' => 'dezasseis', 'dezessete' => 'dezassete', 'dezenove' => 'dezanove', ]; $n = $alias[$n] ?? $n; $words = array_flip(platform_captcha_number_words()); if (isset($words[$n])) { return (string) $words[$n]; } // "07" e "7" são a mesma resposta. if ($n !== '' && ctype_digit($n)) { return (string) (int) $n; } return $n; } /** * Emite um desafio: a pergunta, o token e os nomes dos campos. * * Para quem quer a sua própria marcação — um formulário em grelha, um modal, um * passo de um assistente. Quem só quer um campo normal usa * platform_captcha_field(), que é isto com HTML à volta. * * @return array{question:string, token:string, field_answer:string, field_token:string, id:string} */ function platform_captcha_issue(string $form = 'form', ?PDO $pdo = null): array { $cfg = platform_captcha_config(); $ts = time(); $nonce = bin2hex(random_bytes(9)); $sig = platform_captcha_sign($form, $ts, $nonce, $pdo); $ch = platform_captcha_challenge($form, $nonce, $pdo); return [ 'question' => $ch['question'], 'token' => $ts . '.' . $nonce . '.' . $sig, 'field_answer' => $cfg['field_answer'], 'field_token' => $cfg['field_token'], // Único por instância: a mesma página pode ter dois captchas, e dois // mandam o clique sempre para o primeiro. 'id' => 'captcha-' . substr($nonce, 0, 8), ]; } function platform_captcha_sign(string $form, int $ts, string $nonce, ?PDO $pdo = null): string { return hash_hmac('sha256', 't|' . $form . '|' . $ts . '|' . $nonce, platform_captcha_key($pdo)); } /** * O bloco pronto a imprimir dentro de um

. * * Sem JavaScript, sem imagens e sem dependências: um , um de * texto e um campo escondido. `inputmode="numeric"` fica de fora de propósito — * metade dos desafios pede uma letra, e um teclado numérico num campo onde se * escreve "d" é pior do que nenhum. */ function platform_captcha_field(string $form = 'form', ?PDO $pdo = null): string { $cfg = platform_captcha_config(); $c = platform_captcha_issue($form, $pdo); $esc = static fn(string $s): string => htmlspecialchars($s, ENT_QUOTES, 'UTF-8'); $cls = static fn(string $k): string => $cfg[$k] !== '' ? ' class="' . $esc($cfg[$k]) . '"' : ''; $html = '' . '' . $esc($c['question']) . '' . '' . ''; if ($cfg['help'] !== '') { $html .= '' . $esc($cfg['help']) . ''; } return $html . ''; } /** * Verifica a resposta. Devolve null quando passa, ou a mensagem a mostrar. * * **Falha fechada**, ao contrário do portão de país: um token que não chegou é * um token inválido. O captcha só existe se a ausência dele for uma recusa — * caso contrário bastava não enviar o campo. É por isso que um site que se * esqueça de imprimir o campo vê o formulário recusado em vez de aberto: o erro * aparece ao primeiro teste, em vez de ficar uma defesa desligada em silêncio. * * A mensagem devolvida é para mostrar a quem preencheu, já em português e já * genérica: nunca diz qual das verificações falhou. */ function platform_captcha_verify(string $form = 'form', ?PDO $pdo = null): ?string { $cfg = platform_captcha_config(); $expired = 'A verificação expirou. Responda à nova pergunta e envie outra vez.'; $wrong = 'A resposta à pergunta de verificação não está certa. Tente de novo.'; $token = (string) ($_POST[$cfg['field_token']] ?? ''); $parts = explode('.', $token); if (count($parts) !== 3) { platform_captcha_offence($pdo, $form, 'token em falta ou malformado', (bool) $cfg['offence_forged']); return $expired; } [$ts, $nonce, $sig] = $parts; if (!ctype_digit($ts) || !ctype_xdigit($nonce) || !ctype_xdigit($sig) || !hash_equals(platform_captcha_sign($form, (int) $ts, $nonce, $pdo), $sig)) { platform_captcha_offence($pdo, $form, 'token forjado', (bool) $cfg['offence_forged']); return $expired; } // 60 s de folga para o futuro: o carimbo é feito no servidor, mas um relógio // que ande atrasado depois de um restauro não há-de recusar toda a gente até // alguém reparar. $age = time() - (int) $ts; if ($age > (int) $cfg['ttl'] || $age < -60) { return $expired; } if (platform_captcha_used($nonce, false)) { return $expired; } // Marcado antes de comparar, e não depois: é o que torna cada pergunta uma // única tentativa. Marcar só em caso de sucesso deixava o token vivo para as // vinte tentativas seguintes, que é precisamente o ataque. platform_captcha_used($nonce, true, (int) $ts + (int) $cfg['ttl']); $given = (string) ($_POST[$cfg['field_answer']] ?? ''); if (trim($given) === '') { return 'Responda à pergunta de verificação.'; } $ch = platform_captcha_challenge($form, $nonce, $pdo); if (!hash_equals( platform_captcha_canonical_answer($ch['answer']), platform_captcha_canonical_answer($given) )) { platform_captcha_offence($pdo, $form, 'resposta errada', (bool) $cfg['offence_wrong']); return $wrong; } return null; } /** O mesmo, em booleano, para quem já tem a sua própria mensagem. */ function platform_captcha_ok(string $form = 'form', ?PDO $pdo = null): bool { return platform_captcha_verify($form, $pdo) === null; } /** * Nonces já verificados, guardados na sessão. * * Usa apenas a sessão que já estiver aberta — **não** chama session_start(). Numa * página pública isso punha um cookie a toda a gente que passasse por um * formulário, o que muda a política de cookies do site e estraga qualquer cache * à frente. Sem sessão esta defesa não corre, e fica o ttl curto a limitar. */ function platform_captcha_used(string $nonce, bool $mark, int $expiresAt = 0): bool { $cfg = platform_captcha_config(); if (!$cfg['single_use'] || session_status() !== PHP_SESSION_ACTIVE) { return false; } $now = time(); $used = $_SESSION['platform_captcha_used'] ?? []; if (!is_array($used)) { $used = []; } // Limpeza a cada passagem: sem isto a sessão cresce para sempre num site com // um captcha no rodapé. $used = array_filter($used, static fn($exp): bool => (int) $exp > $now); $seen = isset($used[$nonce]); if ($mark) { $used[$nonce] = $expiresAt > 0 ? $expiresAt : $now + 900; // Tecto: um bot com cookies pediria mil desafios e enchia a sessão. if (count($used) > 60) { $used = array_slice($used, -60, null, true); } } $_SESSION['platform_captcha_used'] = $used; return $seen; } /** * Dá memória às falhas, quando há base de dados e o functions_ip_ban.php está * carregado. Silencioso e sem consequências quando não há — um captcha não há-de * exigir tabelas para poder fazer uma pergunta. */ function platform_captcha_offence(?PDO $pdo, string $form, string $detail, bool $enabled): void { if (!$enabled || !($pdo instanceof PDO) || !function_exists('platform_ip_record_offence')) { return; } platform_ip_record_offence($pdo, 'captcha:' . mb_substr($form, 0, 28), $detail, platform_client_ip()); } // ─── O recurso: uma segunda oportunidade a quem foi recusado ──────────────── // // O problema concreto, e é o que fez nascer este módulo: o portão de país // recusa quem chega de fora de Portugal, e isso apanha duas pessoas que não são // spam nenhum — quem usa o iCloud Private Relay (a Apple faz sair o tráfego por // endereços que as listas da ipdeny atribuem a outro país) e os emigrantes. // Ambos recebiam a página de obrigado e ficavam à espera de uma resposta que // nunca vinha, porque a submissão tinha sido deitada fora em silêncio. // // A recusa silenciosa continua a ser a coisa certa para um bot. O que estava // errado era não haver caminho nenhum de volta para uma pessoa. Então: // // 1. a submissão recusada é guardada inteira, com a razão; // 2. em vez da página de obrigado, a pessoa vê uma pergunta; // 3. respondendo certo, a submissão original é libertada e o site trata-a // como se tivesse passado à primeira. // // Três decisões que vale a pena não desfazer sem pensar: // // **Nem todos os motivos dão recurso.** O honeypot e o carimbo forjado ficam de // fora (ver `appeal_never`): não têm falso positivo possível, e oferecer ali uma // segunda tentativa é explicar a um bot o que o apanhou. // // **A submissão fica no servidor, não no browser.** O segundo ecrã só devolve a // resposta ao desafio. Reenviar o conteúdo num campo escondido deixava editá-lo // depois de ter sido pontuado — passava-se uma mensagem limpa na primeira volta // e o texto verdadeiro na segunda. // // **O recurso não é preso ao IP.** Seria o reflexo natural e estragava // exactamente o caso que isto veio resolver: o Private Relay muda o endereço de // saída entre pedidos, e a pessoa voltaria com um IP diferente daquele com que // foi recusada. O que prende o recurso é a assinatura do token. /** * A fila de recursos. Criada à cabeça, como as tabelas do functions_ip_ban.php: * um site não há-de precisar de uma migração para poder desfazer um engano. */ function platform_captcha_appeal_ensure_table(PDO $pdo): bool { static $done = null; if ($done !== null) { return $done; } $cfg = platform_captcha_config(); $table = (string) $cfg['appeal_table']; if (!preg_match('/^[A-Za-z0-9_]+$/', $table)) { error_log('[captcha] nome de tabela inválido, recurso desligado: ' . $table); return $done = false; } try { $pdo->exec(" CREATE TABLE IF NOT EXISTS `{$table}` ( `id` INT AUTO_INCREMENT PRIMARY KEY, `form` VARCHAR(40) NOT NULL, `reason` VARCHAR(190) NOT NULL, `payload` MEDIUMTEXT NOT NULL, `ip` VARCHAR(45) NULL, `attempts` INT NOT NULL DEFAULT 0, `created_at` DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP, `claimed_at` DATETIME NULL, KEY `idx_captcha_appeals_ip` (`ip`, `created_at`), KEY `idx_captcha_appeals_age` (`created_at`) ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 "); return $done = true; } catch (Throwable $e) { // Sem tabela não há recurso, e o site comporta-se como antes: recusa // em silêncio. Uma segunda oportunidade que falha não pode derrubar a // primeira defesa. error_log('[captcha] tabela de recursos indisponível: ' . $e->getMessage()); return $done = false; } } /** Este motivo admite recurso? Ver `appeal_never` na configuração. */ function platform_captcha_appeal_allowed(string $reason): bool { $lower = mb_strtolower($reason, 'UTF-8'); foreach (platform_captcha_config()['appeal_never'] as $needle) { if ($needle !== '' && str_contains($lower, mb_strtolower((string) $needle, 'UTF-8'))) { return false; } } return true; } /** * Guarda a submissão recusada e devolve o token do recurso — ou null quando não * há recurso a oferecer, e aí o site faz o que já fazia. * * Chamar logo a seguir a uma recusa, com a razão que a recusa devolveu: * * if (($reason = platform_antispam_check($pdo, 'contacto', ...)) !== null) { * $appeal = platform_captcha_appeal_offer($pdo, 'contacto', $reason); * // $appeal !== null -> mostrar o desafio (ver platform_captcha_appeal_field) * // $appeal === null -> página de obrigado, como sempre * } * * O payload por omissão é o $_POST inteiro menos os campos de mecanismo. Um site * que prefira guardar só o que lhe interessa passa o array que quiser. */ function platform_captcha_appeal_offer( PDO $pdo, string $form, string $reason, ?array $payload = null ): ?string { $cfg = platform_captcha_config(); if (!platform_captcha_appeal_allowed($reason) || !platform_captcha_appeal_ensure_table($pdo)) { return null; } $table = (string) $cfg['appeal_table']; $ip = platform_client_ip(); $payload ??= platform_captcha_appeal_payload(); try { // Limpeza oportunista. Os recursos são raros, portanto sai barato fazê-la // aqui e não há mais um cron para alguém se esquecer de instalar. $pdo->prepare("DELETE FROM `{$table}` WHERE created_at < DATE_SUB(NOW(), INTERVAL ? SECOND)") ->execute([max(3600, (int) $cfg['appeal_ttl'] * 2)]); if ($ip !== null) { $st = $pdo->prepare("SELECT COUNT(*) FROM `{$table}` WHERE ip = ? AND created_at >= DATE_SUB(NOW(), INTERVAL 1 HOUR)"); $st->execute([$ip]); if ((int) $st->fetchColumn() >= (int) $cfg['appeal_max_ip']) { // Já teve as oportunidades que havia para dar. Sem recurso, e // sem dizer porquê. return null; } } $pdo->prepare("INSERT INTO `{$table}` (form, reason, payload, ip) VALUES (?, ?, ?, ?)") ->execute([ mb_substr($form, 0, 40), mb_substr($reason, 0, 190), (string) json_encode($payload, JSON_UNESCAPED_UNICODE | JSON_UNESCAPED_SLASHES), $ip, ]); $id = (int) $pdo->lastInsertId(); } catch (Throwable $e) { error_log('[captcha] recurso não registado: ' . $e->getMessage()); return null; } return $id . '.' . platform_captcha_appeal_sign($id, $form, $pdo); } /** * O que fica guardado de uma submissão retida: o $_POST sem os campos de * mecanismo — o token CSRF, as armadilhas do anti-spam e o próprio captcha. * * Nenhum deles tem sentido depois de a submissão ser libertada (o carimbo vai * estar velho, o honeypot vazio), e guardá-los era guardar um token válido * numa tabela durante duas horas sem precisar. */ function platform_captcha_appeal_payload(?array $post = null): array { $cfg = platform_captcha_config(); $payload = $post ?? $_POST; unset( $payload['csrf_token'], $payload['_pt_csrf'], $payload['antispam_token'], $payload['form_sig'], $payload['form_js'], $payload['form_ts'], $payload['website'], $payload[$cfg['field_answer']], $payload[$cfg['field_token']], $payload['captcha_appeal'] ); return $payload; } function platform_captcha_appeal_sign(int $id, string $form, ?PDO $pdo = null): string { return hash_hmac('sha256', 'a|' . $form . '|' . $id, platform_derived_key('captcha-appeal', $pdo)); } /** * O bloco do segundo ecrã: o desafio mais o token do recurso. * * O token tem de sobreviver a uma resposta errada, por isso vai num campo * escondido e é reimpresso a cada tentativa — com um desafio novo, porque o * anterior ficou gasto. */ function platform_captcha_appeal_field(string $token, string $form = 'form', ?PDO $pdo = null): string { return '' . platform_captcha_field($form, $pdo); } /** O token do recurso que veio no POST, para reimprimir o ecrã. */ function platform_captcha_appeal_token(): string { return (string) ($_POST['captcha_appeal'] ?? ''); } /** * Tenta libertar a submissão retida. Três respostas possíveis: * * null e $error null — não havia recurso em curso; seguir o fluxo normal * null e $error com texto — havia, e falhou: reimprimir o ecrã com a mensagem * array — libertada. É o $_POST original, para processar * exactamente como se tivesse passado à primeira. * * O site continua a decidir o que fazer com ela — criar a lead, abrir o ticket, * enviar o email. Este módulo não sabe o que aquele formulário significa, e não * é aqui que isso se decide. */ function platform_captcha_appeal_claim(PDO $pdo, string $form = 'form', ?string &$error = null): ?array { $error = null; $cfg = platform_captcha_config(); $token = platform_captcha_appeal_token(); if ($token === '') { return null; } $expired = 'Este pedido já não está disponível. Volte a preencher o formulário, por favor.'; $parts = explode('.', $token); if (count($parts) !== 2 || !ctype_digit($parts[0]) || !ctype_xdigit($parts[1]) || !hash_equals(platform_captcha_appeal_sign((int) $parts[0], $form, $pdo), $parts[1])) { platform_captcha_offence($pdo, $form, 'recurso forjado', (bool) $cfg['offence_forged']); $error = $expired; return null; } if (!platform_captcha_appeal_ensure_table($pdo)) { $error = $expired; return null; } $id = (int) $parts[0]; $table = (string) $cfg['appeal_table']; try { $st = $pdo->prepare( "SELECT payload, attempts, ip, created_at FROM `{$table}` WHERE id = ? AND form = ? AND claimed_at IS NULL AND created_at >= DATE_SUB(NOW(), INTERVAL ? SECOND)" ); $st->execute([$id, mb_substr($form, 0, 40), (int) $cfg['appeal_ttl']]); $row = $st->fetch(PDO::FETCH_ASSOC); } catch (Throwable $e) { error_log('[captcha] recurso não lido: ' . $e->getMessage()); $error = $expired; return null; } // Já libertado, já expirado, ou nunca existiu: a mesma resposta para os três. if (!$row) { $error = $expired; return null; } if ((int) $row['attempts'] >= (int) $cfg['appeal_tries']) { // Gastou as tentativas. Fecha-se o recurso em vez de o deixar aberto a // ser martelado até uma resposta calhar certa. try { $pdo->prepare("UPDATE `{$table}` SET claimed_at = NOW() WHERE id = ?")->execute([$id]); } catch (Throwable) { /* a janela fecha-a de qualquer maneira */ } $error = $expired; return null; } try { $pdo->prepare("UPDATE `{$table}` SET attempts = attempts + 1 WHERE id = ?")->execute([$id]); } catch (Throwable $e) { error_log('[captcha] tentativa não contada: ' . $e->getMessage()); } if (($why = platform_captcha_verify($form, $pdo)) !== null) { $error = $why; // resposta errada: o recurso continua de pé return null; } $payload = json_decode((string) $row['payload'], true); if (!is_array($payload)) { error_log('[captcha] payload do recurso ' . $id . ' ilegível'); $error = $expired; return null; } try { $pdo->prepare("UPDATE `{$table}` SET claimed_at = NOW() WHERE id = ?")->execute([$id]); } catch (Throwable $e) { error_log('[captcha] recurso ' . $id . ' libertado mas não marcado: ' . $e->getMessage()); } platform_captcha_appeal_forgive($pdo, $form, (string) ($row['ip'] ?? ''), (string) $row['created_at']); return $payload; } /** * Apaga as infracções que a recusa desta pessoa gerou. * * Sem isto o recurso era uma armadilha: cada tentativa de contacto somava uma * infracção, e a escada do functions_ip_ban.php bane aos três registos em 24 h — * ou seja, a terceira vez que um utilizador do Private Relay tentasse falar * connosco ficava sem acesso ao site, depois de nós próprios lhe termos * confirmado que era humano. * * **Não levanta banimentos**, e é a única parte disto que é uma escolha e não * uma consequência. Um captcha que desfizesse um banimento seria um oráculo: * resolve-se um desafio e recupera-se o acesso, o que é um alvo bem mais * apetecível do que um formulário de contacto. Quem já está banido fala com uma * pessoa, pelo email do ecrã de 403. */ function platform_captcha_appeal_forgive(PDO $pdo, string $form, string $ip, string $since): void { if ($ip === '' || $since === '') { return; } try { // Só as infracções daquele formulário, daquele endereço, desde o momento // em que a submissão foi retida. O historial anterior fica de pé. $pdo->prepare( "DELETE FROM ip_offences WHERE ip = ? AND kind IN (?, ?) AND created_at >= DATE_SUB(?, INTERVAL 5 SECOND)" )->execute([$ip, 'antispam:' . $form, 'captcha:' . $form, $since]); } catch (Throwable $e) { // Tabela por criar (o site não usa o ip_ban) ou apagada: não é motivo // para não libertar a submissão, que é o que a pessoa veio buscar. error_log('[captcha] infracções do recurso não limpas: ' . $e->getMessage()); } }