DEV Community: Marcelo

Spring boot + Keycloak - protegendo suas APIs (parte 2)

Marcelo — Fri, 30 Jul 2021 16:48:51 +0000

Na primeira parte do tutorial foi incluído uma segurança básica nas nossas APIs. Nesta segunda parte vamos adicionar regras de autorização utilizando os authorities do contidos no nosso token JWT.
Em primeiro lugar, vamos alterar nosso application.yaml e mudar a propriedade e o endpoint do keycloak utilizado. Agora vai ficar assim:

spring.security.oauth2.resourceserver.jwt.jwk-set-uri=http://localhost:8080/auth/realms/security-api/protocol/openid-connect/certs

Lembrando que nesse endpoint security-api é o nome do nosso realm criado no keycloak.

Vamos agora criar uma classe que vai ser responsável por extrair as authorities do token JWT criado pelo Keycloak.

import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import lombok.RequiredArgsConstructor;
import org.springframework.core.convert.converter.Converter;
import org.springframework.security.authentication.AbstractAuthenticationToken;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.authority.AuthorityUtils;
import org.springframework.security.oauth2.jwt.Jwt;
import org.springframework.security.oauth2.server.resource.authentication.JwtAuthenticationToken;
import org.springframework.security.oauth2.server.resource.authentication.JwtGrantedAuthoritiesConverter;
import org.springframework.stereotype.Component;

import java.util.Collection;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
import java.util.stream.Collectors;
import java.util.stream.Stream;

/**
 * Classe responsavel por converter o token gerado pelo Keycloak
 * de maneira a atribuir os authorities do jeito que o spring security
 * utiliza.
 */
@Component
@RequiredArgsConstructor
public class KeycloakJwtAuthenticationConverter implements Converter<Jwt, AbstractAuthenticationToken> {

    private final JwtGrantedAuthoritiesConverter defaultGrantedAuthoritiesConverter = new JwtGrantedAuthoritiesConverter();
    private final ObjectMapper objectMapper;

    @Override
    public AbstractAuthenticationToken convert(Jwt jwt) {
        Collection<GrantedAuthority> authorities = Stream
                .concat(defaultGrantedAuthoritiesConverter.convert(jwt).stream()
                        , extractAuthorities(jwt).stream())
                .collect(Collectors.toSet());
        return new JwtAuthenticationToken(jwt, authorities);
    }

    /**
     * orquestra a extração dos authorities
     * @param jwt
     * @return Collection<GrantedAuthority> contendo as roles e scopes do jwt
     */
    private Collection<GrantedAuthority> extractAuthorities(Jwt jwt) {
        Set<String> rolesWithPrefix = new HashSet<>();
        rolesWithPrefix.addAll(getRealmRoles(jwt));
        rolesWithPrefix.addAll(getResourceRoles(jwt));
        return AuthorityUtils.createAuthorityList(rolesWithPrefix.toArray(new String[0]));
    }

    /**
     * Busca as roles de acesso ao realm
     * @param jwt
     * @return uma colection contendo as roles
     */
    private Set<String> getRealmRoles(Jwt jwt) {
        Set<String> rolesWithPrefix = new HashSet<>();
        JsonNode json = objectMapper.convertValue(jwt.getClaim("realm_access"), JsonNode.class);
        json.elements().forEachRemaining(
                e -> e.elements().forEachRemaining(r -> rolesWithPrefix.add(createRole(r.asText()))));
        return rolesWithPrefix;
    }

    /**
     * Busca as roles de acesso a determinado resource
     * @param jwt
     * @return uma colection contendo as roles
     */
    private Set<String> getResourceRoles(Jwt jwt) {
        Set<String> rolesWithPrefix = new HashSet<>();
        Map<String, JsonNode> map = objectMapper.convertValue(jwt.getClaim("resource_access"), new TypeReference<Map<String, JsonNode>>(){});
        for (Map.Entry<String, JsonNode> jsonNode : map.entrySet()) {
            jsonNode
                    .getValue()
                    .elements()
                    .forEachRemaining(e -> e
                            .elements()
                            .forEachRemaining(r -> rolesWithPrefix.add(createRole(jsonNode.getKey(), r.asText()))));
        }
        return rolesWithPrefix;
    }

    private String createRole(String... values) {
        StringBuilder role = new StringBuilder("ROLE");
        for (String value : values) {
            role.append("_").append(value.toUpperCase());
        }
        return role.toString();
    }
}

Adicionei pra cada role um prefixo ROLE_ e para as roles de determinado resource o prefixo inclui também o nome do resource.
Agora vamos criar uma classe para configuração do spring security.

import lombok.RequiredArgsConstructor;
import org.springframework.security.config.annotation.method.configuration.EnableGlobalMethodSecurity;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;

@EnableWebSecurity
@EnableGlobalMethodSecurity(prePostEnabled = true)
@RequiredArgsConstructor
public class ResourceServerConfig extends WebSecurityConfigurerAdapter {

    private final KeycloakJwtAuthenticationConverter keycloakJwtAuthenticationConverter;

    @Override
    public void configure(final HttpSecurity http) throws Exception {
        http
                .authorizeRequests(authz -> authz.antMatchers("/security/**").authenticated())
                .oauth2ResourceServer()
                .jwt().jwtAuthenticationConverter(keycloakJwtAuthenticationConverter);
    }
}

Aqui, além de habilitar a segurança, habilitei também o @PreAuthorize e o @PostAuthorize. Estas anotações recebem expressões, escritas em SpEL (Spring Expression Language), e trabalham validando no token se o cliente da requisição possui permissões para acessar aquele método ou ter acesso ao que ocorreu após a execução do método, como os nomes das anotações sugerem. Você pode encontrar mais sobre expression-based access control na documentação do spring neste link
Nas configurações do spring security, informei que apenas endpoint s iniciados por /security precisam ser validados e setei a classe que criamos acima como um converter para o token JWT.

Pra testar, vamos criar os endpoints necessários:

import org.springframework.http.ResponseEntity;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping(value = "/security")
public class SecurityResource {

    /**
     * endpoint sem nenhuma validação de role
     */
    @GetMapping
    public ResponseEntity<Void> isAuthenticated() {
        return ResponseEntity.ok().build();
    }

    /**
     * endpoint onde o usuario tem que ter a role user
     */
    @GetMapping(value = "/has-role")
    @PreAuthorize("hasAnyAuthority('ROLE_USER')")
    public ResponseEntity<Void> isUser() {
        return ResponseEntity.ok().build();
    }

    /**
     * endpoint onde o usuario tem que ter a role admin
     */
    @GetMapping(value = "/is-admin")
    @PreAuthorize("hasAnyAuthority('ROLE_ADMIN')")
    public ResponseEntity<Void> isAdmin() {
        return ResponseEntity.ok().build();
    }

}

No nosso projeto esta tudo pronto. Qualquer endpoint que iniciar com security necessita do token JWT criado pelo nosso Keycloak e conseguimos validar os authorities contidos neste JWT utilizando as anotações do spring.

Agora no Keycloak precisamos criar as roles e alguns usuários para o teste.

Criando as roles:

Criando os usuários:

Criando usuário:

Depois de criado, na aba Credentials adicione uma senha, altere o Temporary pra OFF e clique em Set Password pra criar a senha do usuário.

Agora vamos setar a role ao usuário. Criamos 2 roles (admin e user) e criamos 3 usuários (admin e user). Vamos setar a role de acordo com o usuário criado.
Na aba Role Mappings selecione a role no quadro Available Roles e clique no botão Add selected abaixo do quadro:

Pronto, vamos testar.
No postman, naquele mesmo request do tutorial anterior, vamos alterar o formato do token que vamos requisitar. Pra isso altere a key grant_type para password. Além disto, adicione as keys username e password com seus respectivos valores.

Neste primeiro exemplo busquei o token com o usuário user e este usuário tem apenas a role user. Nos endpoints que criamos o usuário com esta role teria acesso ao endpoint /security/has-role mas não ao /security/is-admin.

Perfeito... funcionando!
Já um token do usuário admin que tem a role admin o acesso ao /security/is-admin funciona:

Bom, é isso!
Configuramos o Keycloak para nos permitir criar tokens, autenticando usuários e atribuindo a eles determinadas permissões. Configuramos nosso projeto spring para validar este token e utilizar os dados contidos no JWT para dar autorizações para os usuários dentro da nossa aplicação.

A primeira parte deste tutorial esta aqui e o código utilizado de exemplo esta no meu github

Grande abraço!

Spring boot + Keycloak - protegendo suas APIs (parte 1)

Marcelo — Fri, 16 Jul 2021 20:55:33 +0000

Segurança em APIs?

Tem APIs nos teus serviços? Como esta a segurança destas APIs?
Temos algumas maneiras de aplicar seguranças nas nossas APIs. Uma delas é a autenticação e autorização utilizando OpenID/OAuth2.

Keycloak

Pra que desenvolver se já temos ferramentas prontas?
O Keycloak é uma ferramenta open source que prove autenticação e autorização para serviços utilizando alguns protocolos como OpenID, OAuth2 e SAML. Ele tem integração com LDAP, AD e redes sociais.
Para testarmos, vamos subir uma instância do docker:
docker run --name keycloak -p 8080:8080 -e KEYCLOAK_USER=admin -e KEYCLOAK_PASSWORD=admin quay.io/keycloak/keycloak:14.0.0
Ele sobe uma instância do H2 e mesmo que o serviço for reiniciado não vai perder as configurações que fizermos.

Configurando o Keycloak

O serviço vai subir na porta 8080 e pode ser acessado pela url http://localhost:8080

Quando subimos o docker, setamos um usuário e senha iniciais (KEYCLOAK_USER=admin e KEYCLOAK_PASSWORD=admin). Clique em "Administration Console", informe o usuário/senha para entrar no console.

A primeira coisa que precisamos fazer dentro do console é a criação de um realm. Podemos entender aqui que o realm é a representação da sua aplicação, podemos ter varias aplicações rodando na mesma instância do Keycloak.
Por default já é criado um realm master, é onde existe a conta de admin criado inicialmente e só iremos utiliza-lo para a criação de outros realms.
Então no canto superior esquerdo, vamos clicar em "Add realm".

O próximo passo é criar e configurar o client. Na aba lateral esquerda, clique em "Clients" e depois no botão "Create".

Depois de salvo, iremos editar as seguintes propriedades do client.

Aqui a url foi adicionada apenas por ser requerida, não iremos utiliza-la.
Estas alterações são necessárias para que, utilizando este client-id, conseguirmos adquirir um token para acesso as APIs.

Aplicação

Vamos criar um projeto simples utilizando o Spring Initializr.

Abra o projeto na sua IDE, edite o application.properties e adicione a porta que sua aplicação vai subir:

server.port=8090

Vamos adicionar o controller abaixo:

Subindo o projeto e fazendo um teste básico no postman podemos ver que o endpoint esta completamente aberto, sem nenhuma segurança.

Agora vamos adicionar a segurança. Edite o pom.xml e adicione as dependências necessárias:

        <dependency>
            <groupId>org.springframework.security</groupId>
            <artifactId>spring-security-config</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-oauth2-resource-server</artifactId>
        </dependency>

Só de adicionar as dependências, nossos endpoints já não estarão mais expostos.

Agora vamos informar ao spring security qual é a url de validação do token. Vamos editar o application.properties e vamos adicionar a propriedades necessária:

spring.security.oauth2.resourceserver.jwt.issuer-uri=http://localhost:8080/auth/realms/security-api

Atenção ao ultimo elemento da url, ele é o nome do seu realm.

E isso é o básico que precisamos para ter nossa API segura.

Pegando um token

Vamos pegar um access token no Keycloak pra testar nosso endpoint. A url para buscar o access token é:
http://localhost:8080/auth/realms/security-api/protocol/openid-connect/token
Lembrando que security-api é o nome do realm.
No postman, crie um request POST utilizando esta url acima. No body do request vamos enviar o seguinte:

client_id: é o nome do client que foi criado no keycloak, no nosso caso é web-app.
client_secret: aqui precisamos pegar o valor gerado lá no cadastro do client no keycloak. Edite o client, vá na aba "Credentials" e copie o valor de "Secret"
grant_type: vamos setar "client_credentials", pois iremos gerar um token de um client cadastrado no keycloak.

Testando o endpoint seguro

Vamos copiar o valor do campo "access_token" do response e vamos editar o request ao nosso serviço. Este token deve ser incluído no header do request com a key Authorization e no value incluiremos um prefixo que mostra o tipo do token que será Bearer. Vai ficar assim:

Por ora é isto... vamos melhorar este código na parte 2.

O código deste tutorial esta no github

Já saiu a segunda parte de tutorial, você pode ver aqui