Quais são as principais práticas de segurança em PHP?

Question

Accepted Answer

Segurança em PHP significa se defender contra as vulnerabilidades web comuns (OWASP Top 10) em cada camada — manipulação de entrada, acesso ao banco de dados, saída, autenticação e configuração. Como PHP alimenta grande parte da web, essas práticas são críticas.

## 1. Prevenir SQL injection — prepared statements

```php
// ❌ NEVER concatenate user input into SQL
$pdo->query("SELECT * FROM users WHERE id = " . $_GET['id']);   // INJECTION
// ✅ ALWAYS use prepared statements (input treated as data, not SQL)
$stmt = $pdo->prepare("SELECT * FROM users WHERE id = ?");
$stmt->execute([$_GET['id']]);
```

## 2. Prevenir XSS — escape de toda saída

```php
// ❌ echoing raw user input → XSS (injected scripts run in the browser)
echo $_GET['name'];
// ✅ escape output for HTML context
echo htmlspecialchars($_GET['name'], ENT_QUOTES, 'UTF-8');
```

Escape de dados controlados pelo usuário na saída (`htmlspecialchars`) para que HTML/JS injetado não possa ser executado. (Mecanismos de templating como Twig/Blade fazem escape automático.)

## 3. Hash de senhas adequadamente

```php
// ✅ use password_hash (bcrypt/argon2) — never plaintext, never MD5/SHA
$hash = password_hash($password, PASSWORD_DEFAULT);
// verify:
if (password_verify($input, $hash)) { /* correct password */ }
```

O `password_hash`/`password_verify` nativo do PHP usa algoritmos fortes, com salt e lentos — a forma correta de armazenar senhas.

## 4. Prevenir CSRF — tokens

```php
// generate a token, store in the session, include in forms, verify on submit
$_SESSION['csrf'] = bin2hex(random_bytes(32));
// verify on POST: hash_equals($_SESSION['csrf'], $_POST['csrf'])
```

## 5. Validar e sanitizar toda entrada

```php
$email = filter_var($_POST['email'], FILTER_VALIDATE_EMAIL);   // validate
$id = (int) $_GET['id'];                                        // cast/whitelist
// never trust $_GET/$_POST/$_COOKIE — validate everything
```

## 6. Configuração segura e outras práticas

```text
✓ display_errors=Off in production (don't leak stack traces/internals to users — log instead)
✓ Keep secrets in env vars / config outside the web root, NOT in code/git
✓ Use HTTPS; set secure/httponly/samesite cookie flags
✓ Keep PHP and dependencies UPDATED (composer audit for vulnerable packages)
✓ Validate file uploads (type, size); store outside the web root
✓ Use a maintained framework (Laravel/Symfony) — they handle many protections by default
```

## Por que isso importa

Segurança é crítica para aplicações PHP, e entender essas práticas é essencial — porque PHP alimenta uma enorme porção da web, apps PHP são alvos constantes de ataques, e falhas de segurança podem ser catastróficas (vazamentos de dados, comprometimento de contas, desfiguração).

PHP aborda as vulnerabilidades web mais comuns e perigosas, mas diferentemente de alguns frameworks, muito depende do desenvolvedor seguir as práticas corretas.

Os essenciais inegociáveis: **prepared statements** previnem SQL injection (um dos ataques mais comuns e devastadores), **escape de saída** (`htmlspecialchars`) previne XSS, **`password_hash`/`password_verify`** garantem armazenamento seguro de senhas (nunca plaintext/hashes fracos), **tokens CSRF** protegem requisições que alteram estado, e **validação rigorosa de entrada** (nunca confiar em `$_GET`/`$_POST`/`$_COOKIE`) é a fundação.

Igualmente importante é **configuração segura**: desligar a exibição de erros em produção (erros vazam informações sensíveis para atacantes), manter segredos fora do código, usar HTTPS e flags de cookie seguras, validar uploads e manter PHP e dependências atualizados (já que pacotes vulneráveis são um vetor de ataque importante).

Entender essa abordagem em camadas, defense-in-depth — e que uma única camada negligenciada (uma injection, um segredo vazado, uma saída não escapada, uma dependência não corrigida) pode comprometer todo o sistema — é conhecimento importante e de alto risco para qualquer desenvolvedor PHP.

Embora frameworks modernos (Laravel, Symfony) forneçam muitas proteções por padrão, entender as ameaças subjacentes e as práticas é responsabilidade essencial para construir aplicações seguras, tornando este um tópico crítico e frequentemente relevante para PHP em produção.