Spring-Security-OAuth2: Custom Dynamic Client Registration

Já discutimos Como configurar uma autenticação OAuth 2.0 e como criar um armazenamento de token personalizado. No último artigo desta série, você aprenderá a implementar um registro de cliente dinâmico personalizado usando segurança de primavera-oauth2. Eu recomendo que você leia Parte 1 e Parte 2 primeiro, pois vamos continuar de onde paramos.

Vamos começar criando a entidade responsável por armazenar os dados do cliente:

import com.couchbase.client.java.repository.annotation.Id;
import lombok.Data;
import lombok.NoArgsConstructor;
import org.springframework.data.couchbase.core.mapping.Document;

import javax.validation.constraints.NotNull;
import java.util.*;

@NoArgsConstructor
@Data
@Document
public class CustomClientDetails extends BasicEntity {

    @Id
    @NotNull
    private String id;

    @NotNull
    private String clientId;
    private String clientSecret;
    private Set<String> resourceIds = new HashSet<>();
    private boolean secretRequired;
    private boolean scoped;
    private Set<String> scope = new HashSet<>();
    private Set<String> authorizedGrantTypes = new HashSet<>();
    private Set<String> registeredRedirectUri = new HashSet<>();
    private Collection<String> authorities = new HashSet<>();
    private Integer accessTokenValiditySeconds;
    private  Integer refreshTokenValiditySeconds;
    private boolean autoApprove;
    private Map<String, Object> additionalInformation = new HashMap<>();
}

importação com.couchbase.cliente.java.repositório.anotação.Id;

importação lombok.Dados;

importação lombok.NoArgsConstructor;

importação org.estrutura de mola.dados.couchbase.núcleo.mapeamento.Documento;

importação javax.validação.restrições.Não nulo;

importação java.util.*;

@NoArgsConstructor

@Data

@Documento

público classe Detalhes do cliente personalizado se estende BasicEntity {

@Id

@NotNull

privado Cordas id;

@NotNull

privado Cordas clienteId;

privado Cordas clientSecret;

privado Conjunto<String> resourceIds = novo HashSet<>();

privado booleano secretRequired;

privado booleano com escopo;

privado Conjunto<String> escopo = novo HashSet<>();

privado Conjunto<String> authorizedGrantTypes = novo HashSet<>();

privado Conjunto<String> registeredRedirectUri = novo HashSet<>();

privado Coleção<String> autoridades = novo HashSet<>();

privado Inteiro accessTokenValiditySeconds;

privado Inteiro refreshTokenValiditySeconds;

privado booleano autoAprovar;

privado Mapa<Cordas, Objeto> additionalInformation = novo HashMap<>();

}

Aqui está o respectivo repositório:

import org.springframework.data.couchbase.core.query.N1qlPrimaryIndexed;
import org.springframework.data.couchbase.core.query.ViewIndexed;
import org.springframework.data.couchbase.repository.CouchbasePagingAndSortingRepository;


@N1qlPrimaryIndexed
@ViewIndexed(designDoc = "customClientDetails")
public interface CustomClientDetailsRepository extends CouchbasePagingAndSortingRepository<CustomClientDetails, String> {

    CustomClientDetails findByClientId(String clientId);
}

importação org.estrutura de mola.dados.couchbase.núcleo.consulta.N1qlPrimaryIndexed;

importação org.estrutura de mola.dados.couchbase.núcleo.consulta.ViewIndexed;

importação org.estrutura de mola.dados.couchbase.repositório.CouchbasePagingAndSortingRepository;

@N1qlPrimaryIndexed

@ViewIndexed(designDoc = "customClientDetails")

público interface CustomClientDetailsRepository se estende CouchbasePagingAndSortingRepository<Detalhes do cliente personalizado, Cordas> {

Detalhes do cliente personalizado findByClientId(Cordas clienteId);

}

Agora, podemos implementar o ClientDetailsService da classe de segurança do Spring:

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.oauth2.provider.ClientDetails;
import org.springframework.security.oauth2.provider.ClientDetailsService;
import org.springframework.security.oauth2.provider.ClientRegistrationException;
import org.springframework.security.oauth2.provider.client.BaseClientDetails;
import org.springframework.stereotype.Service;

import java.util.stream.Collectors;

@Service
public class CouchbaseClientDetailsService implements ClientDetailsService {

    @Autowired
    private CustomClientDetailsRepository customClientDetailsRepository;

    @Override
    public ClientDetails loadClientByClientId(String clientId) throws ClientRegistrationException {

        CustomClientDetails client = customClientDetailsRepository.findByClientId(clientId);

        String resourceIds = client.getResourceIds().stream().collect(Collectors.joining(","));
        String scopes = client.getScope().stream().collect(Collectors.joining(","));
        String grantTypes = client.getAuthorizedGrantTypes().stream().collect(Collectors.joining(","));
        String authorities = client.getAuthorities().stream().collect(Collectors.joining(","));

        BaseClientDetails base = new BaseClientDetails(client.getClientId(), resourceIds, scopes, grantTypes, authorities);
        base.setClientSecret(client.getClientSecret());
        base.setAccessTokenValiditySeconds(client.getAccessTokenValiditySeconds());
        base.setRefreshTokenValiditySeconds(client.getRefreshTokenValiditySeconds());
        base.setAdditionalInformation(client.getAdditionalInformation());
        base.setAutoApproveScopes(client.getScope());
        return base;
    }
}

importação org.estrutura de mola.feijões.fábrica.anotação.Com fio automático;

importação org.estrutura de mola.segurança.oauth2.provedor.ClientDetails;

importação org.estrutura de mola.segurança.oauth2.provedor.ClientDetailsService;

importação org.estrutura de mola.segurança.oauth2.provedor.ClientRegistrationException;

importação org.estrutura de mola.segurança.oauth2.provedor.cliente.BaseClientDetails;

importação org.estrutura de mola.estereótipo.Serviço;

importação java.util.fluxo.Colecionadores;

@Serviço

público classe CouchbaseClientDetailsService implementa ClientDetailsService {

@Com fio automático

privado CustomClientDetailsRepository customClientDetailsRepository;

@Substituir

público ClientDetails loadClientByClientId(Cordas clienteId) lançamentos ClientRegistrationException {

Detalhes do cliente personalizado cliente = customClientDetailsRepository.findByClientId(clienteId);

Cordas resourceIds = cliente.getResourceIds().fluxo().coletar(Colecionadores.união(","));

Cordas escopos = cliente.getScope().fluxo().coletar(Colecionadores.união(","));

Cordas grantTypes = cliente.getAuthorizedGrantTypes().fluxo().coletar(Colecionadores.união(","));

Cordas autoridades = cliente.getAuthorities().fluxo().coletar(Colecionadores.união(","));

BaseClientDetails base = novo BaseClientDetails(cliente.getClientId(), resourceIds, escopos, grantTypes, autoridades);

base.setClientSecret(cliente.getClientSecret());

base.setAccessTokenValiditySeconds(cliente.getAccessTokenValiditySeconds());

base.setRefreshTokenValiditySeconds(cliente.getRefreshTokenValiditySeconds());

base.setAdditionalInformation(cliente.getAdditionalInformation());

base.setAutoApproveScopes(cliente.getScope());

retorno base;

}

Observe que estou usando o BaseClientDetails em vez de implementar a classe ClientDetails interface. Essa parece ser a melhor opção, pois até mesmo a implementação padrão do JDBC a utiliza.

Por fim, precisamos alterar nosso AuthorizationServerConfig para usar nosso CouchbaseClientDetailsService:

@Configuration
@EnableAuthorizationServer
public class AuthorizationServerConfig extends AuthorizationServerConfigurerAdapter {

    @Autowired
    private CouchbaseClientDetailsService couchbaseClientDetailsService;

    @Override
    public void configure(ClientDetailsServiceConfigurer configurer) throws Exception {
        configurer.withClientDetails(couchbaseClientDetailsService);
    }

}

@Configuração

@EnableAuthorizationServer

público classe AuthorizationServerConfig se estende AuthorizationServerConfigurerAdapter {

@Autowired

privado CouchbaseClientDetailsService couchbaseClientDetailsService;

@Override

público vazio configurar(ClientDetailsServiceConfigurer configurador) lançamentos Exceção {

configurador.comClientDetails(couchbaseClientDetailsService);

}

Esta é a aparência da classe inteira:

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.authentication.AuthenticationManager;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.security.oauth2.config.annotation.configurers.ClientDetailsServiceConfigurer;
import org.springframework.security.oauth2.config.annotation.web.configuration.AuthorizationServerConfigurerAdapter;
import org.springframework.security.oauth2.config.annotation.web.configuration.EnableAuthorizationServer;
import org.springframework.security.oauth2.config.annotation.web.configurers.AuthorizationServerEndpointsConfigurer;
import org.springframework.security.oauth2.config.annotation.web.configurers.AuthorizationServerSecurityConfigurer;
import org.springframework.security.oauth2.provider.token.TokenStore;


@Configuration
@EnableAuthorizationServer
public class AuthorizationServerConfig extends AuthorizationServerConfigurerAdapter {

    @Autowired
    private TokenStore tokenStore;

    @Autowired
    private AuthenticationManager authenticationManager;

    @Autowired
    private CouchbaseClientDetailsService couchbaseClientDetailsService;

    @Autowired
    private PasswordEncoder passwordEncoder;

    @Override
    public void configure(ClientDetailsServiceConfigurer configurer) throws Exception {
        configurer.withClientDetails(couchbaseClientDetailsService);
    }

    @Override
    public void configure(AuthorizationServerEndpointsConfigurer endpoints) throws Exception {
        endpoints.tokenStore(tokenStore)
                .authenticationManager(authenticationManager);
    }

    @Override
    public void configure(
            AuthorizationServerSecurityConfigurer oauthServer)
            throws Exception {
        oauthServer
                .tokenKeyAccess("permitAll()")
                .checkTokenAccess("isAuthenticated()");
    }

}

importação org.estrutura de mola.feijões.fábrica.anotação.Com fio automático;

importação org.estrutura de mola.contexto.anotação.Configuração;

importação org.estrutura de mola.segurança.autenticação.Gerenciador de autenticação;

importação org.estrutura de mola.segurança.criptografia.senha.PasswordEncoder;

importação org.estrutura de mola.segurança.oauth2.configuração.anotação.configuradores.ClientDetailsServiceConfigurer;

importação org.estrutura de mola.segurança.oauth2.configuração.anotação.web.configuração.AuthorizationServerConfigurerAdapter;

importação org.estrutura de mola.segurança.oauth2.configuração.anotação.web.configuração.EnableAuthorizationServer (Ativar servidor de autorização);

importação org.estrutura de mola.segurança.oauth2.configuração.anotação.web.configuradores.AuthorizationServerEndpointsConfigurer;

importação org.estrutura de mola.segurança.oauth2.configuração.anotação.web.configuradores.AuthorizationServerSecurityConfigurer;

importação org.estrutura de mola.segurança.oauth2.provedor.token.TokenStore;

@Configuração

@EnableAuthorizationServer

público classe AuthorizationServerConfig se estende AuthorizationServerConfigurerAdapter {

@Autowired

privado TokenStore tokenStore;

@Autowired

privado Gerenciador de autenticação gerenciador de autenticação;

@Autowired

privado CouchbaseClientDetailsService couchbaseClientDetailsService;

@Autowired

privado PasswordEncoder passwordEncoder;

@Override

público vazio configurar(ClientDetailsServiceConfigurer configurador) lançamentos Exceção {

configurador.comClientDetails(couchbaseClientDetailsService);

}

@Override

público vazio configurar(AuthorizationServerEndpointsConfigurer pontos finais) lançamentos Exceção {

pontos finais.tokenStore(tokenStore)

.gerenciador de autenticação(gerenciador de autenticação);

}

@Override

público vazio configurar(

AuthorizationServerSecurityConfigurer oauthServer)

lançamentos Exceção {

oauthServer

.tokenKeyAccess("permitAll()")

.checkTokenAccess("isAuthenticated()");

}

Agora você pode simplesmente inserir um novo cliente em seu banco de dados e usar essas credenciais para autenticar via OAuth:

    static final String GRANT_TYPE_PASSWORD = "password";
    static final String AUTHORIZATION_CODE = "authorization_code";
    static final String REFRESH_TOKEN = "refresh_token";
    static final String IMPLICIT = "implicit";
    static final String SCOPE_READ = "read";
    static final String SCOPE_WRITE = "write";
    static final String TRUST = "trust";

    private void createOauthClients() {

        CustomClientDetails client = new CustomClientDetails();
        client.setId("someId");

        client.setResourceIds(new HashSet<>(Arrays.asList("resource_id")) );
        client.setClientId("android-client");
        client.setClientSecret("android-secret");
        client.setAuthorizedGrantTypes(new HashSet<>(Arrays.asList(GRANT_TYPE_PASSWORD, AUTHORIZATION_CODE, REFRESH_TOKEN, IMPLICIT)));
        client.setScope(new HashSet<>(Arrays.asList(SCOPE_READ, SCOPE_WRITE, TRUST)));
        client.setSecretRequired(true);
        client.setAccessTokenValiditySeconds(50000);
        client.setRefreshTokenValiditySeconds(50000);
        client.setScoped(false);

        customClientDetailsRepository.save(client);
    }

estático final Cordas GRANT_TYPE_PASSWORD = "senha";

estático final Cordas AUTHORIZATION_CODE = "authorization_code";

estático final Cordas REFRESH_TOKEN = "refresh_token";

estático final Cordas IMPLÍCITO = "implícito";

estático final Cordas SCOPE_READ = "ler";

estático final Cordas SCOPE_WRITE = "escrever";

estático final Cordas CONFIANÇA = "confiança";

privado vazio createOauthClients() {

Detalhes do cliente personalizado cliente = novo Detalhes do cliente personalizado();

cliente.setId("someId");

cliente.setResourceIds(novo HashSet<>(Matrizes.asList("resource_id")) );

cliente.setClientId("android-client");

cliente.setClientSecret("android-secret");

cliente.setAuthorizedGrantTypes(novo HashSet<>(Matrizes.asList(GRANT_TYPE_PASSWORD, AUTHORIZATION_CODE, REFRESH_TOKEN, IMPLÍCITO)));

cliente.setScope(novo HashSet<>(Matrizes.asList(SCOPE_READ, SCOPE_WRITE, CONFIANÇA)));

cliente.setSecretRequired(verdadeiro);

cliente.setAccessTokenValiditySeconds(50000);

cliente.setRefreshTokenValiditySeconds(50000);

cliente.setScoped(falso);

customClientDetailsRepository.salvar(cliente);

}

TL;DR - O truque é implementar o org.springframework.security.oauth2.provider.ClientDetailsService e passá-la como um parâmetro para sua interface ClientDetailsServiceConfigurer:

    @Override
    public void configure(ClientDetailsServiceConfigurer configurer) throws Exception {
        configurer.withClientDetails(couchbaseClientDetailsService);
    }

@Override

público vazio configurar(ClientDetailsServiceConfigurer configurador) lançamentos Exceção {

configurador.comClientDetails(couchbaseClientDetailsService);

}

Se você tiver alguma dúvida, envie-me um tweet para @deniswsrosa

Denis Rosa, defensor dos desenvolvedores, Couchbase

Platform

Self-Managed

Services

Capabilities

Why Couchbase?

Migrate to Capella

By Use Case

By Industry

By Application Need

Popular Docs

By Developer Role

COMMUNITY

Join the Developer Community

Resource Center

Education

Compare

About

Partnerships

Our Services

Partners: Register a Deal

Ready to register a deal with Couchbase?

Marriott

Todas as publicações

Segurança do Spring e registro dinâmico de clientes | OAuth Parte 3

Autor

Postado por Denis Rosa, defensor dos desenvolvedores, Couchbase

Deixar uma resposta Cancelar resposta