Contexto: segurança como prática integrada

Ao trabalhar com TypeScript, a tipagem estática reduz a superfície de erro, mas não elimina vulnerabilidades presentes em runtime e na integração com dependências. Minha abordagem é combinar tipagem rigorosa com validação de dados em tempo de execução, padrões de autenticação robustos e uma arquitetura que minimize a superfície de ataque. A ideia é simples: codificar com segurança por padrão, não como adição tardia.

Neste post, compartilho como eu structurei um fluxo de trabalho seguro em TS, incluindo decisões de tsconfig, validação de entrada, proteção de APIs e práticas de autenticação/autorizações que se mantêm estáveis conforme o projeto cresce.

Typing estrito e validação em tempo de execução

Use o strict mode do TypeScript e o tipo unknown para dados de entrada. Evito qualquer com “any” e prefiro guardas de tipo (type guards) que transformam desconhecido em tipos compiláveis, com tratamento de erros claro. A validação não substitui a tipagem estática, mas a complementa para cenários de input externo (APIs, mensagens de fila, payloads de UI).

type User = { id: string; email: string; role: 'admin'|'user' };

function parseUser(input: unknown): User {
  if (typeof input !== 'object' || input === null) {
    throw new TypeError('Invalid input: expected object');
  }
  const obj = input as { id?: unknown; email?: unknown; role?: unknown };

  if (typeof obj.id !== 'string') {
    throw new TypeError('Invalid input: id must be string');
  }
  if (typeof obj.email !== 'string' ) {
    throw new TypeError('Invalid input: email must be string');
  }
  if (typeof obj.role !== 'string' || !['admin','user'].includes(obj.role)) {
    throw new TypeError('Invalid input: role must be "admin" or "user"');
  }

  return { id: obj.id, email: obj.email, role: obj.role as User['role'] };
}

// Exemplo de uso seguro
function handlePayload(payload: unknown): User {
  const user = parseUser(payload);
  // lógico de negócio aqui, sem surpresas por tipos incorretos
  return user;
}

Observação: esse padrão evita que dados externos “tragam” qualquer tipo indevido para o runtime da aplicação, mantendo a confiança na lógica de negócio e reduzindo erros de produção associados a inputs malformados.

Práticas de runtime e proteção de entrada

• Valide todas as entradas antes de qualquer processamento, especialmente dados vindos de APIs, formulários ou mensagens assíncronas.
• Evite interpolação de strings para construção de queries. Prefira consultas parametrizadas/ORMs que separam código de dados.
• Implemente escaping/normalização quando exibir dados em HTML ou logs, para evitar XSS e divulgação acidental de informações sensíveis.
• Utilize checagens de permissões antes de ações sensíveis e trate erros de forma explícita para não expor detalhes internos.

Exemplo de consulta segura (pseudo-código, com parâmetros):

// Supondo um client de banco com suporte a consultas parametrizadas
async function getUserByEmail(email: string) {
  const result = await db.query('SELECT id, email, role FROM users WHERE email = $1', [email]);
  return result.rows[0] ?? null;
}

Arquitetura segura: autenticação, autorização e surface area

Segurança não é apenas código; é arquitetura. Abaixo os pilares que sigo para manter a superfície de ataque sob controle:

• Autenticação: prefiro tokens com validação de assinatura em backend confiável; utilize HttpOnly cookies para sessões quando cabível, reduzindo a superfície de ataque via XSS.
• Autorização: aplique o princípio do menor privilégio; verifique permissões no backend antes de ações críticas e não apenas no frontend.
• CSRF e CORS: configure SameSite em cookies, use políticas estritas de CORS e valide origens quando necessário.
• Gestão de segredos: não comite segredos; use mecanismos de vault/serviço de configuração segura e rotação periódica.
• Logging e observabilidade: registre falhas de autenticação/autorizações com padrões que não expõem dados sensíveis, e mantenha traces úteis para auditoria.

Outra prática importante é manter read-only pela API pública onde possível, e isolar componentes sensíveis em microserviços com fronteiras bem definidas.