Como Construir um Sistema de Autenticação com Claude Code (JWT e OAuth)

Vantagens de Usar o Claude Code para Construção de Sistemas de Autenticação

Autenticação é uma funcionalidade diretamente ligada à segurança, e erros de implementação levam a vulnerabilidades graves. O Claude Code gera implementações seguindo as melhores práticas de segurança e também sugere contramedidas para vetores de ataque frequentemente negligenciados.

Implementação de Autenticação JWT

> Implemente autenticação JWT com Express + TypeScript.
> Sistema de 2 tokens com Access Token (15 min) e Refresh Token (7 dias).
> Gerencie o Refresh Token como cookie httpOnly.

Serviço de Autenticação

import jwt from 'jsonwebtoken';
import bcrypt from 'bcrypt';
import { prisma } from './db';

const ACCESS_TOKEN_SECRET = process.env.ACCESS_TOKEN_SECRET!;
const REFRESH_TOKEN_SECRET = process.env.REFRESH_TOKEN_SECRET!;

interface TokenPayload {
  userId: string;
  email: string;
}

export class AuthService {
  async register(email: string, password: string, name: string) {
    const existing = await prisma.user.findUnique({ where: { email } });
    if (existing) throw new Error('E-mail já registrado');

    const hashedPassword = await bcrypt.hash(password, 12);
    const user = await prisma.user.create({
      data: { email, password: hashedPassword, name },
    });

    return this.generateTokens({ userId: user.id, email: user.email });
  }

  async login(email: string, password: string) {
    const user = await prisma.user.findUnique({ where: { email } });
    if (!user) throw new Error('Credenciais inválidas');

    const valid = await bcrypt.compare(password, user.password);
    if (!valid) throw new Error('Credenciais inválidas');

    return this.generateTokens({ userId: user.id, email: user.email });
  }

  async refreshToken(token: string) {
    const payload = jwt.verify(token, REFRESH_TOKEN_SECRET) as TokenPayload;

    // Verificar validade do refresh token no BD
    const stored = await prisma.refreshToken.findFirst({
      where: { token, userId: payload.userId, revoked: false },
    });
    if (!stored) throw new Error('Refresh token inválido');

    // Invalidar token antigo (rotação de token)
    await prisma.refreshToken.update({
      where: { id: stored.id },
      data: { revoked: true },
    });

    return this.generateTokens(payload);
  }

  private async generateTokens(payload: TokenPayload) {
    const accessToken = jwt.sign(payload, ACCESS_TOKEN_SECRET, {
      expiresIn: '15m',
    });
    const refreshToken = jwt.sign(payload, REFRESH_TOKEN_SECRET, {
      expiresIn: '7d',
    });

    await prisma.refreshToken.create({
      data: { token: refreshToken, userId: payload.userId },
    });

    return { accessToken, refreshToken };
  }
}

Middleware de Autenticação

import { Request, Response, NextFunction } from 'express';
import jwt from 'jsonwebtoken';

export function authMiddleware(req: Request, res: Response, next: NextFunction) {
  const header = req.headers.authorization;
  if (!header?.startsWith('Bearer ')) {
    return res.status(401).json({ error: 'Nenhum token fornecido' });
  }

  const token = header.slice(7);

  try {
    const payload = jwt.verify(token, process.env.ACCESS_TOKEN_SECRET!);
    req.user = payload as TokenPayload;
    next();
  } catch (err) {
    return res.status(401).json({ error: 'Token inválido ou expirado' });
  }
}

Configuração do Router

import { Router } from 'express';
import { AuthService } from './auth-service';

const router = Router();
const auth = new AuthService();

router.post('/register', async (req, res) => {
  try {
    const { accessToken, refreshToken } = await auth.register(
      req.body.email, req.body.password, req.body.name
    );
    res.cookie('refreshToken', refreshToken, {
      httpOnly: true,
      secure: true,
      sameSite: 'strict',
      maxAge: 7 * 24 * 60 * 60 * 1000,
    });
    res.json({ accessToken });
  } catch (err) {
    res.status(400).json({ error: (err as Error).message });
  }
});

router.post('/login', async (req, res) => {
  try {
    const { accessToken, refreshToken } = await auth.login(
      req.body.email, req.body.password
    );
    res.cookie('refreshToken', refreshToken, {
      httpOnly: true,
      secure: true,
      sameSite: 'strict',
      maxAge: 7 * 24 * 60 * 60 * 1000,
    });
    res.json({ accessToken });
  } catch (err) {
    res.status(401).json({ error: 'Credenciais inválidas' });
  }
});

router.post('/refresh', async (req, res) => {
  try {
    const token = req.cookies.refreshToken;
    const { accessToken, refreshToken } = await auth.refreshToken(token);
    res.cookie('refreshToken', refreshToken, {
      httpOnly: true,
      secure: true,
      sameSite: 'strict',
      maxAge: 7 * 24 * 60 * 60 * 1000,
    });
    res.json({ accessToken });
  } catch (err) {
    res.status(401).json({ error: 'Refresh token inválido' });
  }
});

export default router;

Integração OAuth (Google)

> Adicione login com Google usando PassportJS. Integre com a autenticação JWT existente.

import passport from 'passport';
import { Strategy as GoogleStrategy } from 'passport-google-oauth20';

passport.use(new GoogleStrategy({
  clientID: process.env.GOOGLE_CLIENT_ID!,
  clientSecret: process.env.GOOGLE_CLIENT_SECRET!,
  callbackURL: '/auth/google/callback',
}, async (accessToken, refreshToken, profile, done) => {
  let user = await prisma.user.findFirst({
    where: { providerId: profile.id, provider: 'google' },
  });

  if (!user) {
    user = await prisma.user.create({
      data: {
        email: profile.emails![0].value,
        name: profile.displayName,
        provider: 'google',
        providerId: profile.id,
      },
    });
  }

  done(null, user);
}));

Checklist de Segurança

Você pode pedir ao Claude Code uma auditoria de segurança com o seguinte prompt.

> Revise o código de autenticação do ponto de vista de segurança.
> Verifique com base no OWASP Top 10.

Os principais pontos de verificação são:

• O bcrypt está sendo usado para hash de senhas?
• A chave secreta do JWT é suficientemente longa?
• A rotação de refresh tokens está implementada?
• Há proteção contra CSRF?
• O rate limiting está configurado?

Para manter a qualidade do código incluindo segurança, a automação de refatoração também é eficaz. Se você documentar as diretrizes de autenticação no CLAUDE.md, o Claude Code gerará código consistente.

Resumo

Com o Claude Code, você pode construir eficientemente um sistema de autenticação robusto incluindo autenticação JWT e integração OAuth. Como o código é gerado seguindo as melhores práticas de segurança, fica mais fácil lidar com vulnerabilidades frequentemente negligenciadas. Em ambiente de produção, certifique-se de garantir o gerenciamento seguro de chaves secretas e comunicação HTTPS.

Para mais informações, consulte a documentação oficial da Anthropic.