OAuth 2.0 e autorização JWT em Kotlin: guia completo para iniciantes

O que são OAuth 2.0 e JWT e por que são necessários em Kotlin?

No desenvolvimento web moderno, a segurança de dados e o gerenciamento de acesso são tarefas fundamentais. Se você está escrevendo uma aplicação servidor em Kotlin, mais cedo ou mais tarde enfrentará a necessidade de proteger uma API ou organizar login através de serviços de terceiros (Google, GitHub, VK). Para isso, existem dois padrões — OAuth 2.0 (protocolo de autorização) e JWT (JSON Web Token — formato de token).

Neste artigo, vamos analisar como funcionam OAuth 2.0 e JWT, e implementar uma autorização simples em Kotlin usando bibliotecas populares. O material é voltado para iniciantes, portanto todos os termos complexos serão explicados de forma simples.

Conceitos básicos: OAuth 2.0 e JWT

O que é OAuth 2.0?

OAuth 2.0 é um protocolo que permite que um serviço (por exemplo, sua aplicação) obtenha acesso limitado aos recursos de um usuário em outro serviço (por exemplo, ao perfil dele no Google) sem transmitir login e senha. Imagine que você queira entrar em um site usando sua conta do Google — isso é OAuth 2.0.

Principais participantes do OAuth 2.0:

\n
• Resource Owner — o usuário, proprietário dos dados.
\n
• Client — sua aplicação, que deseja obter acesso.
\n
• Authorization Server — servidor que emite a permissão (ex.: Google).
\n
• Resource Server — servidor que armazena os dados do usuário (ex.: API do Google).
\n

O que é JWT?

JWT é um formato de token compacto e autossuficiente que contém informações sobre o usuário (ex.: ID, função, data de expiração). O token é assinado digitalmente, portanto não pode ser falsificado. O JWT consiste em três partes separadas por pontos:

header.payload.signature

Exemplo de JWT decodificado:

{\n  "sub": "1234567890",\n  "name": "João Silva",\n  "iat": 1516239022,\n  "exp": 1516242622\n}

A principal vantagem do JWT é que o servidor não precisa armazenar sessões no banco de dados. Toda a informação já está dentro do token.

Implementação de autorização JWT em Kotlin com Spring Boot

Vamos considerar um exemplo prático. Criaremos uma API REST em Kotlin usando Spring Boot e Spring Security. Nossa aplicação emitirá um token JWT após autenticação bem-sucedida.

Passo 1. Adicionar dependências

Adicione as seguintes dependências no build.gradle.kts:

dependencies {\n    implementation("org.springframework.boot:spring-boot-starter-security")\n    implementation("org.springframework.boot:spring-boot-starter-web")\n    implementation("io.jsonwebtoken:jjwt-api:0.12.5")\n    runtimeOnly("io.jsonwebtoken:jjwt-impl:0.12.5")\n    runtimeOnly("io.jsonwebtoken:jjwt-jackson:0.12.5")\n}

Passo 2. Criar o serviço JWT

Criaremos a classe JwtService, que irá gerar e verificar tokens:

import io.jsonwebtoken.Claims\nimport io.jsonwebtoken.Jwts\nimport io.jsonwebtoken.security.Keys\nimport org.springframework.stereotype.Service\nimport java.util.*\n\n@Service\nclass JwtService {\n    private val secretKey = "mySecretKeyForJwtToken12345678901234567890" // mínimo 32 caracteres\n    private val expirationMs = 3600000L // 1 hora\n\n    fun generateToken(username: String): String {\n        val claims: Map = mapOf(\n            "sub" to username,\n            "iat" to Date(),\n            "exp" to Date(System.currentTimeMillis() + expirationMs)\n        )\n        return Jwts.builder()\n            .claims(claims)\n            .signWith(Keys.hmacShaKeyFor(secretKey.toByteArray()))\n            .compact()\n    }\n\n    fun extractUsername(token: String): String? {\n        return try {\n            val claims = parseToken(token)\n            claims.subject\n        } catch (e: Exception) {\n            nul