Quais são as melhores práticas de segurança importantes para um aplicativo Node.js?

Question

Accepted Answer

Proteger um aplicativo Node significa se defender contra vulnerabilidades comuns da web (OWASP Top 10) em múltiplas camadas — validação de entrada, autenticação, dependências e configuração. Segurança é em camadas (defesa em profundidade), não um único conserto.

## 1. Valide e sanitize toda entrada

```js
import { z } from "zod";
// never trust client input — validate shape/type before using it
const schema = z.object({ email: z.string().email(), age: z.number().min(0) });
const data = schema.parse(req.body); // rejects malformed/malicious input
```

## 2. Previna injeção (SQL, NoSQL, command)

```js
// ❌ string concatenation → SQL injection
db.query(`SELECT * FROM users WHERE id = ${req.params.id}`);
// ✅ parameterized queries — input is data, never executable SQL
db.query("SELECT * FROM users WHERE id = $1", [req.params.id]);
```

Sempre use consultas parametrizadas / um ORM e nunca construa comandos a partir de entrada do usuário (veja injeção de comando com `child_process`).

## 3. Autenticação & segredos

```text
✓ Hash passwords with bcrypt/argon2/scrypt (slow + salted) — never plain/SHA
✓ Store secrets in env vars, never in code/git
✓ Use httpOnly, secure, sameSite cookies for sessions (XSS-resistant)
✓ Sign/verify JWTs properly; keep tokens short-lived
```

## 4. Defina cabeçalhos de segurança & rate-limit

```js
import helmet from "helmet";
import rateLimit from "express-rate-limit";

app.use(helmet()); // sets secure HTTP headers (CSP, HSTS, X-Frame-Options, etc.)
app.use(rateLimit({ windowMs: 60_000, max: 100 })); // throttle abuse/brute-force
```

`helmet` adiciona cabeçalhos protetores; rate limiting se defende contra brute-force e DoS.

## 5. Mantenha as dependências seguras (supply chain)

```bash
npm audit          # check installed packages for known vulnerabilities
npm audit fix
# + keep deps updated; review postinstall scripts; pin versions via the lockfile
```

Mais código Node é pacotes de terceiros — dependências vulneráveis são um grande vetor de ataque. Audite e atualize regularmente.

## 6. Outras essências

```text
✓ Use HTTPS (TLS) everywhere; redirect HTTP → HTTPS
✓ Don't leak error details/stack traces to clients in production
✓ Escape output to prevent XSS (frameworks usually do this)
✓ Implement proper authorization (not just authentication) — check permissions per action
✓ CORS configured to an allowlist, not "*" for credentialed APIs
✓ Limit request body size to prevent payload-based DoS
```

## Por que isso importa

Aplicações web são alvos constantes, e aplicativos Node são expostos a toda a gama de vulnerabilidades web — injeção, autenticação quebrada, XSS, dependências vulneráveis, má configuração.

Nenhuma medida única é suficiente; segurança é **em camadas**: valide entrada, parametrize consultas, hash de senhas corretamente, gerencie segredos com segurança, defina cabeçalhos protetores, rate-limit, audite dependências e use HTTPS.

Compreender essas práticas (e os riscos OWASP por trás delas) é responsabilidade essencial para qualquer pessoa que construa serviços Node de produção — uma única camada esquecida (uma injeção, um segredo vazado, uma dependência não corrigida) pode comprometer todo o sistema.