OAuth 2.1 e OpenID Connect: padrões de autenticação para produção em 2026

A evolução da autenticação moderna

Autenticação em produção não é mais sobre "login com Facebook" ou "Google Sign-in". É sobre autorização granular, tokens com lifecycle controlado, fluxos específicos para cada tipo de cliente e conformidade com regulamentos como GDPR e LGPD.

OAuth 2.1, consolidado em 2026, resolve ambiguidades históricas do OAuth 2.0 e torna obrigatórias práticas de segurança que eram opcionais. Para equipes de engenharia, isso significa menos interpretação e mais clareza sobre o que é seguro e o que não é.

OpenID Connect (OIDC), construído sobre OAuth 2.1, adiciona a camada de identidade que OAuth puro não fornece. Enquanto OAuth autoriza o acesso a recursos, OIDC fornece identidade do usuário através de um ID Token padronizado.

OAuth 2.1: mudanças obrigatórias que impactam produção

1. PKCE é obrigatório para clientes públicos

OAuth 2.0 permitia PKCE (Proof Key for Code Exchange) como opcional para clientes públicos (SPAs, mobile apps). OAuth 2.1 torna PKCE obrigatório para todos os clientes públicos.

Por que isso importa:

Sem PKCE, fluxos de autenticação em SPAs e mobile apps são vulneráveis a ataques de authorization code interception. PKCE previne isso requerendo que o cliente prove que iniciou a requisição.

typescript// PKCE flow para SPA
class PKCEOAuthClient {
  async initiateAuthorization() {
    // Gerar code verifier (criptograficamente seguro)
    const codeVerifier = this.generateRandomString(128);

    // Criar code challenge usando SHA-256
    const codeChallenge = await this.sha256(codeVerifier);

    // Armazenar verifier temporariamente
    sessionStorage.setItem('pkce_verifier', codeVerifier);

    // Redirecionar para auth endpoint com code_challenge
    const authUrl = new URL('https://auth.example.com/authorize');
    authUrl.searchParams.set('response_type', 'code');
    authUrl.searchParams.set('client_id', this.clientId);
    authUrl.searchParams.set('redirect_uri', this.redirectUri);
    authUrl.searchParams.set('code_challenge', codeChallenge);
    authUrl.searchParams.set('code_challenge_method', 'S256');
    authUrl.searchParams.set('scope', 'openid profile email');
    authUrl.searchParams.set('state', this.generateState());

    window.location.href = authUrl.toString();
  }

  async exchangeCodeForToken(authorizationCode: string) {
    const codeVerifier = sessionStorage.getItem('pkce_verifier');

    // Trocar código por tokens enviando o code_verifier
    const response = await fetch('https://auth.example.com/token', {
      method: 'POST',
      headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
      body: new URLSearchParams({
        grant_type: 'authorization_code',
        code: authorizationCode,
        redirect_uri: this.redirectUri,
        client_id: this.clientId,
        code_verifier: codeVerifier // Prova de autoria
      })
    });

    return await response.json();
  }

  private generateRandomString(length: number): string {
    const array = new Uint8Array(length);
    crypto.getRandomValues(array);
    return Array.from(array, byte => byte.toString(16).padStart(2, '0')).join('');
  }

  private async sha256(message: string): Promise<string> {
    const encoder = new TextEncoder();
    const data = encoder.encode(message);
    const hash = await crypto.subtle.digest('SHA-256', data);
    return btoa(String.fromCharCode(...new Uint8Array(hash)))
      .replace(/\+/g, '-')
      .replace(/\//g, '_')
      .replace(/=+$/, '');
  }
}

2. Refresh tokens com rotação obrigatória

OAuth 2.1 torna obrigatória a rotação de refresh tokens para clients públicos. Quando um novo refresh token é emitido, o anterior é invalidado imediatamente.

typescript// Refresh token rotation no backend
class TokenService {
  async refreshAccessToken(refreshToken: string, clientInfo: ClientInfo) {
    // 1. Validar refresh token atual
    const tokenData = await this.validateRefreshToken(refreshToken);

    if (!tokenData) {
      throw new InvalidTokenError('Invalid or expired refresh token');
    }

    // 2. Invalidar refresh token anterior (rotação obrigatória)
    await this.invalidateToken(refreshToken);

    // 3. Gerar novo access token
    const newAccessToken = await this.generateAccessToken(tokenData.userId);

    // 4. Gerar novo refresh token
    const newRefreshToken = await this.generateRefreshToken(tokenData.userId, clientInfo);

    // 5. Registrar rotação para detecção de roubo de token
    await this.logTokenRotation(tokenData.userId, refreshToken, newRefreshToken);

    return {
      access_token: newAccessToken,
      refresh_token: newRefreshToken,
      expires_in: 3600
    };
  }

  async validateRefreshToken(token: string) {
    // Verificar token na base de dados/Redis
    const tokenData = await this.redis.get(`refresh_token:${token}`);

    if (!tokenData) {
      return null;
    }

    // Verificar expiração
    const parsed = JSON.parse(tokenData);
    if (Date.now() > parsed.expiresAt) {
      await this.redis.del(`refresh_token:${token}`);
      return null;
    }

    return parsed;
  }
}

3. Proibição de credenciais em URL

OAuth 2.1 proíbe passar client_secret em query parameters ou fragmentos de URL. Credenciais devem sempre ser enviadas no corpo da requisição HTTP, codificadas como application/x-www-form-urlencoded.

typescript// CORRETO: client_secret no corpo da requisição
const response = await fetch('https://auth.example.com/token', {
  method: 'POST',
  headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
  body: new URLSearchParams({
    grant_type: 'client_credentials',
    client_id: clientId,
    client_secret: clientSecret // ✅ Seguro: no corpo
  })
});

// INCORRETO: client_secret em query parameter
const response = await fetch(`https://auth.example.com/token?client_secret=${clientSecret}`); // ❌ Inseguro

4. Redirecionamentos seguros são obrigatórios

OAuth 2.1 requer HTTPS para todos os endpoints de autorização e token. Adicionalmente, redirect_uri deve usar protocolos seguros (HTTPS, custom schemes como myapp:// para mobile).

OpenID Connect: adicionando identidade ao OAuth

OIDC define três tokens padrão:

Validação de ID Token

typescriptclass OIDCTokenValidator {
  async validateIDToken(idToken: string, config: OIDCConfig): Promise<TokenPayload> {
    const decoded = await this.verifyJWT(idToken, config.issuer);

    // Validações obrigatórias OIDC
    this.validateIssuer(decoded, config.issuer);
    this.validateAudience(decoded, config.clientId);
    this.validateExpiration(decoded);
    this.validateIssuedAt(decoded);
    this.validateNonce(decoded, config.nonce);

    return decoded;
  }

  private validateIssuer(token: TokenPayload, expectedIssuer: string) {
    if (token.iss !== expectedIssuer) {
      throw new ValidationError('Invalid issuer in ID Token');
    }
  }

  private validateAudience(token: TokenPayload, expectedAudience: string) {
    if (!token.aud.includes(expectedAudience)) {
      throw new ValidationError('Invalid audience in ID Token');
    }
  }

  private validateExpiration(token: TokenPayload) {
    if (Date.now() >= token.exp * 1000) {
      throw new ValidationError('ID Token expired');
    }
  }

  private validateIssuedAt(token: TokenPayload) {
    const clockSkew = 300; // 5 minutos de tolerância
    if (Date.now() < token.iat * 1000 - clockSkew) {
      throw new ValidationError('ID Token issued in the future');
    }
  }
}

Fluxos de autenticação por tipo de cliente

1. SPA (Single Page Application)

Fluxo recomendado: Authorization Code Flow com PKCE

typescript// SPA OAuth 2.1 client
class SPAOAuthClient {
  constructor(
    private clientId: string,
    private redirectUri: string,
    private authEndpoint: string,
    private tokenEndpoint: string
  ) {}

  async login(): Promise<void> {
    const codeVerifier = this.generatePKCEVerifier();
    const codeChallenge = await this.generatePKCEChallenge(codeVerifier);
    const state = this.generateState();

    // Armazenar para uso no callback
    sessionStorage.setItem('oauth_state', state);
    sessionStorage.setItem('oauth_verifier', codeVerifier);

    const authUrl = new URL(this.authEndpoint);
    authUrl.searchParams.set('response_type', 'code');
    authUrl.searchParams.set('client_id', this.clientId);
    authUrl.searchParams.set('redirect_uri', this.redirectUri);
    authUrl.searchParams.set('code_challenge', codeChallenge);
    authUrl.searchParams.set('code_challenge_method', 'S256');
    authUrl.searchParams.set('scope', 'openid profile email');
    authUrl.searchParams.set('state', state);

    window.location.href = authUrl.toString();
  }

  async handleCallback(code: string, state: string): Promise<Tokens> {
    // Validar state para prevenir CSRF
    const storedState = sessionStorage.getItem('oauth_state');
    if (state !== storedState) {
      throw new SecurityError('Invalid state parameter');
    }

    const verifier = sessionStorage.getItem('oauth_verifier');

    const response = await fetch(this.tokenEndpoint, {
      method: 'POST',
      headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
      body: new URLSearchParams({
        grant_type: 'authorization_code',
        code,
        redirect_uri: this.redirectUri,
        client_id: this.clientId,
        code_verifier: verifier
      })
    });

    const tokens = await response.json();

    // Armazenar tokens de forma segura
    localStorage.setItem('access_token', tokens.access_token);
    localStorage.setItem('refresh_token', tokens.refresh_token);

    return tokens;
  }
}

2. Mobile Application

Fluxo recomendado: Authorization Code Flow com PKCE usando custom scheme

typescript// React Native OAuth 2.1 client
import { Linking } from 'react-native';

class MobileOAuthClient {
  private customScheme = 'myapp://oauth/callback';

  async initiateAuth(): Promise<void> {
    const codeVerifier = this.generateVerifier();
    const codeChallenge = await this.generateChallenge(codeVerifier);
    const state = this.generateState();

    // Armazenar no secure storage
    await SecureStore.setItemAsync('oauth_verifier', codeVerifier);
    await SecureStore.setItemAsync('oauth_state', state);

    const authUrl = `https://auth.example.com/authorize?` + new URLSearchParams({
      response_type: 'code',
      client_id: this.clientId,
      redirect_uri: this.customScheme,
      code_challenge: codeChallenge,
      code_challenge_method: 'S256',
      scope: 'openid profile email',
      state: state
    });

    // Abrir navegador ou app de autenticação
    await Linking.openURL(authUrl);
  }

  setupDeepLinkHandler() {
    Linking.addEventListener('url', async ({ url }) => {
      const parsed = new URL(url);
      const code = parsed.searchParams.get('code');
      const state = parsed.searchParams.get('state');

      if (code && state) {
        await this.handleCallback(code, state);
      }
    });
  }
}

3. Backend Service (Machine-to-Machine)

Fluxo recomendado: Client Credentials Flow

typescript// Backend service OAuth 2.1 client
class ServiceAccountClient {
  private accessToken: string | null = null;
  private tokenExpiry: number = 0;

  async getAccessToken(): Promise<string> {
    // Reutilizar token se ainda válido
    if (this.accessToken && Date.now() < this.tokenExpiry - 60000) {
      return this.accessToken;
    }

    // Obter novo token
    const response = await fetch('https://auth.example.com/token', {
      method: 'POST',
      headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
      body: new URLSearchParams({
        grant_type: 'client_credentials',
        client_id: this.clientId,
        client_secret: this.clientSecret,
        scope: 'api:read api:write'
      })
    });

    const tokens = await response.json();

    this.accessToken = tokens.access_token;
    this.tokenExpiry = Date.now() + tokens.expires_in * 1000;

    return this.accessToken;
  }

  async makeAuthenticatedRequest(url: string, options: RequestInit = {}) {
    const token = await this.getAccessToken();

    const response = await fetch(url, {
      ...options,
      headers: {
        ...options.headers,
        'Authorization': `Bearer ${token}`
      }
    });

    // Se token expirou (401), tentar renovar uma vez
    if (response.status === 401) {
      this.accessToken = null; // Forçar refresh
      const newToken = await this.getAccessToken();

      return fetch(url, {
        ...options,
        headers: {
          ...options.headers,
          'Authorization': `Bearer ${newToken}`
        }
      });
    }

    return response;
  }
}

4. Device Authorization Flow (TV, IoT, CLI)

OAuth 2.1 inclui Device Authorization Flow para dispositivos com interface limitada ou sem navegador.

typescript// Device Authorization Flow para CLI/IoT
class DeviceAuthClient {
  async initiateDeviceAuth(): Promise<DeviceAuthResponse> {
    // 1. Solicitar device code e user code
    const response = await fetch('https://auth.example.com/device/code', {
      method: 'POST',
      headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
      body: new URLSearchParams({
        client_id: this.clientId,
        scope: 'openid profile email'
      })
    });

    const { device_code, user_code, verification_uri, expires_in, interval } = await response.json();

    // 2. Exibir instruções ao usuário
    console.log(`Visit ${verification_uri}`);
    console.log(`Enter code: ${user_code}`);

    // 3. Poll para autorização
    const tokens = await this.pollForToken(device_code, interval, expires_in);

    return tokens;
  }

  private async pollForToken(
    deviceCode: string,
    interval: number,
    expiresIn: number
  ): Promise<Tokens> {
    const startTime = Date.now();

    while (Date.now() - startTime < expiresIn * 1000) {
      const response = await fetch('https://auth.example.com/token', {
        method: 'POST',
        headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
        body: new URLSearchParams({
          grant_type: 'urn:ietf:params:oauth:grant-type:device_code',
          client_id: this.clientId,
          device_code: deviceCode
        })
      });

      const data = await response.json();

      if (data.access_token) {
        return data;
      }

      if (data.error === 'authorization_pending') {
        // Usuário ainda não autorizou, continuar polling
        await this.sleep(interval * 1000);
        continue;
      }

      if (data.error === 'authorization_declined') {
        throw new Error('User declined authorization');
      }

      if (data.error === 'expired_token') {
        throw new Error('Device code expired');
      }
    }

    throw new Error('Authorization timeout');
  }

  private sleep(ms: number): Promise<void> {
    return new Promise(resolve => setTimeout(resolve, ms));
  }
}

Security hardening para produção

1. Token Binding com Proof-of-Possession

Para aplicações críticas, implementar DPoP (Demonstrating Proof-of-Possession) previne replay attacks:

typescript// DPoP header implementation
class DPoPAuthClient {
  async makeDPoPRequest(url: string, method: string, accessToken: string) {
    const dpopHeader = await this.generateDPoPHeader(url, method);

    return fetch(url, {
      method,
      headers: {
        'Authorization': `Bearer ${accessToken}`,
        'DPoP': dpopHeader
      }
    });
  }

  private async generateDPoPHeader(url: string, method: string): Promise<string> {
    const jwk = await this.getDPoPKey();
    const timestamp = Date.now();

    const payload = {
      htu: url, // HTTP Target URI
      htm: method, // HTTP Method
      iat: timestamp, // Issued At
      jti: this.generateJTI() // Unique Identifier
    };

    const header = {
      typ: 'dpop+jwt',
      jwk: jwk,
      alg: 'RS256'
    };

    return await this.signJWT(header, payload);
  }
}

2. Scopes granulares e consentimento explícito

typescript// Gerenciamento de scopes
class ScopeManager {
  private readonly SCOPE_HIERARCHY = {
    // Scopes mais específicos incluem implícitos
    'profile:read': ['profile'],
    'profile:write': ['profile:read'],
    'profile:delete': ['profile:read', 'profile:write'],
    'email:read': ['email'],
    'email:send': ['email:read']
  };

  getImplicitScopes(grantedScopes: string[]): string[] {
    const implicit = new Set<string>();

    for (const scope of grantedScopes) {
      const hierarchy = this.SCOPE_HIERARCHY[scope];
      if (hierarchy) {
        hierarchy.forEach(s => implicit.add(s));
      }
    }

    return Array.from(implicit);
  }

  checkRequiredScopes(required: string[], granted: string[]): boolean {
    const grantedSet = new Set([
      ...granted,
      ...this.getImplicitScopes(granted)
    ]);

    return required.every(scope => grantedSet.has(scope));
  }
}

3. Rate limiting em endpoints de autenticação

typescript// Rate limiting para prevenir brute force
class AuthRateLimiter {
  private readonly MAX_ATTEMPTS = 5;
  private readonly WINDOW_MS = 15 * 60 * 1000; // 15 minutos

  async checkRateLimit(identifier: string): Promise<boolean> {
    const key = `auth_attempts:${identifier}`;
    const attempts = await this.redis.incr(key);

    if (attempts === 1) {
      await this.redis.expire(key, this.WINDOW_MS);
    }

    return attempts <= this.MAX_ATTEMPTS;
  }

  async recordFailedAttempt(identifier: string): Promise<void> {
    await this.checkRateLimit(identifier);
  }

  async resetAttempts(identifier: string): Promise<void> {
    await this.redis.del(`auth_attempts:${identifier}`);
  }
}

Monitoramento e observabilidade

Métricas-chave para autenticação

typescript// Métricas de autenticação
interface AuthMetrics {
  // Taxas de sucesso/falha
  loginSuccessRate: number;
  loginFailureRate: number;
  tokenRefreshRate: number;

  // Tempo médio de autenticação
  averageAuthTimeMs: number;
  p95AuthTimeMs: number;

  // Uso de tokens
  activeAccessTokens: number;
  activeRefreshTokens: number;
  averageTokenLifetime: number;

  // Detecção de anomalias
  unusualLoginPatterns: {
    userId: string;
    location: string;
    device: string;
    timestamp: Date;
  }[];

  // Erros por tipo
  errorsByType: {
    invalidCredentials: number;
    expiredTokens: number;
    invalidGrant: number;
    invalidScope: number;
  };
}

Conclusão

OAuth 2.1 e OpenID Connect em 2026 não são mais luxos técnicos—são fundamentação obrigatória para qualquer sistema que lide com autenticação e autorização em produção.

A mudança mais importante não é técnica, mas cultural: autenticação não pode ser tratada como feature secundária. Ela requer entendimento profundo dos fluxos, implementação rigorosa de segurança e monitoramento contínuo de anomalias.

PKCE, rotação de refresh tokens, validação de ID Tokens e escolha correta do fluxo para cada tipo de cliente não são detalhes—são salvaguardas essenciais que previnem vulnerabilidades reais.

Sua aplicação precisa implementar autenticação moderna e segura? Fale com especialistas em segurança da Imperialis para projetar e implementar OAuth 2.1 e OpenID Connect com as melhores práticas de produção.

Fontes

• OAuth 2.1 Security Best Current Practice (IETF) — Especificação OAuth 2.1
• OpenID Connect Core 1.0 — Especificação OIDC
• RFC 7636: PKCE — Especificação PKCE
• OAuth 2.0 for Browser-Based Apps (OAuth 2.0 BCP) — Melhores práticas para SPAs