Plataformas, Microsserviços, DevOps e APIs · Hands-on 3

Hands-on 3 — Segurança

Faça login uma vez, receba um JSON Web Token (JWT) assinado e deixe o Gateway verificá-lo a cada requisição

Quem é você e o que você pode fazer?

As requisições para /accounts agora chegam da internet. Cada serviço deveria verificar a senha do usuário?

  • Autenticação: verificar quem é o usuário → após o login, emitir um JWT assinado, válido por tempo limitado.
  • Autorização: verificar o que o usuário pode acessar → o Gateway confere o JWT antes de rotear.
  • Um ponto único de entrada: os serviços atrás dele nunca veem uma requisição não autenticada.

Três módulos

internet
→
gatewaya única porta publicada, :8080
→
authlogin, JWT, /auth/solve
→
accounthash da senha, db

gateway, auth e account: todos dentro da camada confiável (a rede do Compose).

Módulo Papel
auth biblioteca de interface: AuthController + DTOs LoginIn, RegisterIn, TokenOut
auth-service implementação: AuthResource, AuthService, JwtService; delega as contas ao account via Feign
gateway-service o ponto único de entrada do hands-on 2, agora com AuthorizationFilter + RouterValidator

Mesmo padrão de account / account-service: cada um é um submódulo git em api/; a biblioteca é instalada com mvn clean install.

JSON Web Token

Três partes em Base64Url separadas por pontos: header . payload . signature — codificadas, não criptografadas

HMACSHA256( base64UrlEncode(header) + "." + base64UrlEncode(payload),
            Base64.decode(JWT_SECRET_KEY) )   // 32 bytes = 256 bits
  • Header: o algoritmo de assinatura — o JJWT escreve só {"alg": "HS256"}.
  • Payload: as claims — declarações sobre o usuário.
  • Signature: prova que o token foi emitido por quem tem o segredo e não foi alterado.
  • Stateless: sem sessão no servidor, então escala horizontalmente.

Quem tem a chave secreta consegue forjar tokens: guarde-a em uma variável de ambiente, nunca fixa no código.

As claims que esta plataforma usa

Claim Campo no JJWT Conteúdo
jti id o identificador único da conta
sub subject o nome da conta
iss issuer a plataforma emissora (Insper::PMA)
nbf notBefore válido a partir deste instante
exp expiration expira neste instante

Mais uma claim personalizada (privada): email. O payload é só codificado, não criptografado — qualquer um pode lê-lo.

O contrato auth

@FeignClient(name="auth", url="http://auth:8080") · nome do cookie AUTH_COOKIE_TOKEN = "__store_jwt_token"

Método Caminho Faz
POST /auth/register create: RegisterIn(name, email, password) → cria a conta
POST /auth/login LoginIn(email, password) → define o cookie JWT
GET /auth/logout apaga o cookie
GET /auth/me header id-account → AccountOut
POST /auth/solve TokenOut(token) → { "idAccount": … } — interno, só o Gateway
GET /auth/health-check 200 OK

Rotas abertas × protegidas: RouterValidator

Cadastro e login precisam ser abertos — senão ninguém conseguiria fazer login.

private List<String> openApiEndpoints = List.of(
    "POST /auth/register",
    "GET /auth/logout",
    "POST /auth/login");

public Predicate<ServerHttpRequest> isSecured = request ->
    openApiEndpoints.stream().noneMatch(/* method and path match, /** = prefix */);

Protegido por padrão: tudo o que não está na lista — inclusive todo /accounts/** — exige um cookie válido.

auth-service

Classe Responsabilidade
AuthApplication @EnableFeignClients(basePackages = "store.account")
AuthResource implementa AuthController; grava o cookie no login/logout
AuthService cadastra via account (AuthParser → Register); no login, o POST /accounts/login confere as credenciais e então pede um token
JwtService assina e interpreta JWTs com a biblioteca JJWT (chave HMAC: segredo de 256 bits → HS256)
store:
  jwt:
    secretKey: ${JWT_SECRET_KEY:EBwrdOOcAIDRLON9hbJV0+O3PTdfTjgMCQIxwLH7ws8=}
    httpOnly: ${JWT_HTTP_ONLY:true}
    duration: ${JWT_DURATION:3600000} # 1 hour in milliseconds

Conferindo as credenciais no account

O auth-service nunca confere senha: o account ganha o POST /accounts/login (AccountController.login).

// account-service: AccountService (calcHash already exists)
public Account findByEmailAndPassword(String email, String password) {
    if (password == null || password.isEmpty())
        throw new ResponseStatusException(BAD_REQUEST, "Password is empty");
    final String hash = calcHash(password);
    return accountRepository.findByEmailAndHashPassword(email, hash)
        .map(AccountModel::to)
        .orElseThrow(() -> new ResponseStatusException(
            UNAUTHORIZED, "Invalid credentials"));
}
  • findByEmailAndHashPassword: uma consulta derivada do Spring Data no AccountRepository. O endpoint responde 200 + AccountOut ou 401.
  • O hash nunca sai do account; o AuthService.login transforma FeignException.Unauthorized / BadRequest em 401.
  • O AccountController mudou: rode mvn clean install em api/account de novo.

JwtService.generate

public String generate(AccountOut account, long duration) {
    Date now = new Date();
    return Jwts.builder()
        .id(account.id())
        .issuer("Insper::PMA")
        .claims(Map.of("email", account.email()))
        .signWith(getKey())  // Keys.hmacShaKeyFor(Base64-decoded secretKey)
        .subject(account.name())
        .notBefore(now)
        .expiration(new Date(now.getTime() + duration))
        .compact();
}

JwtService.getId

public String getId(String jwt) {
    try {
        JwtParser parser = Jwts.parser().verifyWith(getKey()).build();
        // checks the signature, nbf and exp: a JwtException otherwise
        Claims claims = parser.parseSignedClaims(jwt).getPayload();
        return claims.getId();
    } catch (JwtException e) {
        throw new ResponseStatusException(
            HttpStatus.UNAUTHORIZED, "Invalid token");
    }
}

É isso que o /auth/solve executa: um token válido vira um idAccount; um inválido ou expirado, um 401 (não um 500).

  1. POST /auth/login → AuthService.login → POST /accounts/login (confere o hash ou dá 401) → JwtService.generate.
  2. O AuthResource responde com Set-Cookie: __store_jwt_token=<jwt>.
  3. O navegador o guarda e o envia automaticamente em cada requisição seguinte.
Atributo Valor Por quê
HttpOnly true o JavaScript não consegue lê-lo → mitiga XSS (ao contrário do localStorage)
Secure true enviado só por HTTPS
SameSite None enviado em requisições cross-site (frontends SPA)
Path / vale para todos os caminhos

Os navegadores rejeitam SameSite=None sem Secure: em produção, frontend e API precisam usar HTTPS.

O Gateway decide: AuthorizationFilter

Um GlobalFilter: toda requisição passa por ele antes do roteamento.

requisição
→
isSecured?RouterValidator
sim →
cookie__store_jwt_token
→
POST /auth/solveassinatura, nbf, exp
→
+ id-accountpõe o jti e encaminha
rota abertaregister, login, logout: encaminha como está
sem cookie401 Unauthorized
token inválido ou expirado401, mantido pelo onStatus(4xx)

Um id-account enviado pelo cliente é descartado antes (RemoveRequestHeader): ninguém se passa por outra conta.

AuthorizationFilter.filter

public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
    ServerHttpRequest request = exchange.getRequest();
    if (!routerValidator.isSecured.test(request)) {
        return chain.filter(exchange);
    }
    HttpCookie cookie = request.getCookies().getFirst(AUTH_COOKIE_TOKEN);
    if (cookie == null || cookie.getValue().isBlank()) {
        return Mono.error(new ResponseStatusException(HttpStatus.UNAUTHORIZED));
    }
    return requestAuthTokenSolve(exchange, chain, cookie.getValue().trim());
}

O Spring Cloud Gateway é reativo (WebFlux): o filtro devolve Mono<Void>, então a falta do cookie é um Mono.error, não um throw; ele chama o auth com WebClient, não com RestTemplate.

requestAuthTokenSolve: um WebClient, criado uma vez

// constructor: built once from the injected WebClient.Builder, reused by every request
this.authClient = builder.baseUrl("http://auth:8080").build();

return authClient.post().uri("/auth/solve").bodyValue(Map.of("token", jwt))
    .retrieve()
    .onStatus(HttpStatusCode::is4xxClientError,
        r -> Mono.error(new ResponseStatusException(HttpStatus.UNAUTHORIZED, "Invalid token")))
    .bodyToMono(new ParameterizedTypeReference<Map<String, String>>() {})
    .timeout(Duration.ofSeconds(3))
    .flatMap(map -> chain.filter(updateRequest(exchange, map.get("idAccount"))));
auth responde 200
auth responde 4xx
auth calado por 3 s
gateway
+ id-accountencaminha para a rota
401onStatus, não 500
timeoutfalha sem prender a requisição

O cliente é thread-safe: o builder injetado acrescenta métricas (http_client_requests) e tracing. spring-boot-starter-webclient no pom: o Spring Boot 4 o tirou do WebFlux.

Ligando tudo: rotas e Compose

default-filters:
  - RemoveRequestHeader=id-account
routes:
  - id: account-service
    uri: http://account:8080
    predicates:
      - Path=/accounts/**
  - id: auth-service
    uri: http://auth:8080
    predicates:
      - Path=/auth/**
  • Serviço novo: auth (depois do gateway, hands-on 2).
  • Só o gateway publica a porta 8080; o auth fica do lado de dentro.
  • O auth roda com os padrões: JWT_SECRET_KEY, JWT_HTTP_ONLY, JWT_DURATION.
  • gateway: o CORS_ALLOWED_ORIGINS também tem padrão.

A chave padrão é pública (está no repositório): fora do desenvolvimento, defina a JWT_SECRET_KEY com uma sua — openssl rand -base64 32.

Teste

docker compose up -d --build

curl -X POST http://localhost:8080/auth/register -H "Content-Type: application/json" \
  -d '{"name": "Antonio do Estudo", "email": "acme@insper.edu.br", "password": "123@321"}'

curl -c cookies.txt -X POST http://localhost:8080/auth/login -H "Content-Type: application/json" \
  -d '{"email": "acme@insper.edu.br", "password": "123@321"}'

curl -b cookies.txt http://localhost:8080/accounts   # 200 — cookie sent
curl http://localhost:8080/accounts                  # 401 — no cookie

Armadilhas comuns

  • Credenciais erradas → 500: um .orElseThrow() sem argumento lança NoSuchElementException; lance um 401.
  • Cookie expirado → 500: o getId precisa capturar a JwtException; o onStatus do filtro mantém o 401.
  • Build falha depois do login: reinstale a biblioteca account antes de account-service e auth-service.
  • Cookie ignorado: SameSite=None sem Secure é rejeitado pelo navegador.
  • Health check vazando: o /health-check não é rota, o filtro não roda nele — devolva só o hostname.

A JWT_SECRET_KEY padrão está no repositório: qualquer um forjaria tokens para uma implantação que a mantenha.

Sem Docker: o simulador

Autorização 5 (teste)200, 200, 200, 401 · o token da página JWT, byte a byte
tokens ruinssenha errada, id-account forjado, payload editado
forjado com a chave padrão200 como outro usuário, até o JWT_SECRET_KEY ser seu
  • Cada botão é um curl do lab pelo Gateway; as caixas acendem pelo caminho.
  • Os tokens são JWTs HS256 de verdade, assinados com a chave do application.yaml: cole um no jwt.io.
  • Passado o Max-Age do cookie, o curl para de enviá-lo; enviado à mão, o token esbarra em ExpiredJwtException.

Pontos-chave

  1. A autenticação emite um JWT assinado; a autorização o confere a cada requisição.
  2. Um JWT é header.payload.signature; a chave secreta é o que o torna confiável.
  3. O account confere o hash da senha (POST /accounts/login); o JwtService assina jti, sub, iss, nbf, exp, email.
  4. O token viaja em um cookie HttpOnly e Secure: __store_jwt_token.
  5. RouterValidator: só cadastro, login e logout são abertos — protegido por padrão.
  6. O AuthorizationFilter resolve o token via /auth/solve e repassa o id-account.
  7. Os serviços seguintes nunca interpretam JWTs; credenciais ou tokens inválidos são 401, nunca 500.

Roteiro: (1) autenticação × autorização; (2) o JWT e suas claims; (3) a interface auth e as rotas abertas; (4) o auth-service e a conferência das credenciais no account; (5) o cookie; (6) o AuthorizationFilter no gateway; (7) compose, testes e armadilhas.

Deixe a turma responder primeiro: verificar credenciais em cada serviço multiplica a superfície de ataque e o código.

O SHA-256 puro mantém o curso simples; em produção se usa um algoritmo lento e com salt (bcrypt, Argon2, o PasswordEncoder do Spring Security).

Enfatize: os serviços seguintes nunca interpretam JWTs; eles só leem o header id-account.

Um WebClient.builder()...build() dentro do filter() também funciona, mas repete a configuração em toda requisição protegida. É desperdício, não vazamento de memória: medimos 4 rodadas, cerca de 510 mil requisições, e o heap vivo depois de um GC completo ficou estável. O que cresce no docker stats é o heap que a JVM reserva (até 25% da máquina sem limite), não vazamento.

O simulador está na visão geral (tokens ruins) e na seção 5 de Autorização (os quatro comandos da página).