Spring-Security-OAuth2: Custom Dynamic Client Registration

Ya hemos hablado de cómo configurar una autenticación OAuth 2.0 y cómo crear un almacén de fichas personalizado. En el último artículo de esta serie, aprenderá a implementar un registro de cliente dinámico personalizado utilizando spring-seguridad-oauth2. Le recomiendo que lea Parte 1 y Parte 2 primero, ya que vamos a continuar desde donde lo hemos dejado.

Empecemos por crear la entidad responsable de almacenar los datos del 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<>();
}

importar com.couchbase.cliente.java.repositorio.anotación.Id;

importar lombok.Datos;

importar lombok.NoArgsConstructor;

importar org.springframework.datos.couchbase.núcleo.cartografía.Documento;

importar javax.validación.limitaciones.NotNull;

importar java.util.*;

@NoArgsConstructor

@Datos

@Documento

público clase CustomClientDetails extiende Entidad básica {

@Id

@NotNull

privado Cadena id;

@NotNull

privado Cadena clientId;

privado Cadena clientSecret;

privado Establecer<String> resourceIds = nuevo HashSet<>();

privado booleano secretRequired;

privado booleano alcance;

privado Establecer<String> alcance = nuevo HashSet<>();

privado Establecer<String> authorizedGrantTypes = nuevo HashSet<>();

privado Establecer<String> registeredRedirectUri = nuevo HashSet<>();

privado Colección<String> autoridades = nuevo HashSet<>();

privado Entero accessTokenValiditySeconds;

privado Entero refreshTokenValiditySeconds;

privado booleano autoAprobar;

privado Mapa<Cadena, Objeto> información adicional = nuevo HashMap<>();

}

Aquí está el repositorio correspondiente:

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);
}

importar org.springframework.datos.couchbase.núcleo.consulta.N1qlPrimaryIndexed;

importar org.springframework.datos.couchbase.núcleo.consulta.VerIndexado;

importar org.springframework.datos.couchbase.repositorio.CouchbasePagingAndSortingRepository;

@N1qlPrimaryIndexed

@VerIndexado(designDoc = "customClientDetails")

público interfaz CustomClientDetailsRepository extiende CouchbasePagingAndSortingRepository<CustomClientDetails, Cadena> {

CustomClientDetails findByClientId(Cadena clientId);

}

Ahora, podemos implementar el ServicioDeDetallesDelCliente de la clase de seguridad de 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;
    }
}

importar org.springframework.judías.fábrica.anotación.Autowired;

importar org.springframework.seguridad.oauth2.proveedor.DetallesDelCliente;

importar org.springframework.seguridad.oauth2.proveedor.ServicioDeDetallesDelCliente;

importar org.springframework.seguridad.oauth2.proveedor.ClientRegistrationException;

importar org.springframework.seguridad.oauth2.proveedor.cliente.BaseClientDetails;

importar org.springframework.estereotipo.Servicio;

importar java.util.flujo.Coleccionistas;

@Servicio

público clase CouchbaseClientDetailsService implementa ServicioDeDetallesDelCliente {

@Autowired

privado CustomClientDetailsRepository customClientDetailsRepository;

@Anular

público DetallesDelCliente loadClientByClientId(Cadena clientId) lanza ClientRegistrationException {

CustomClientDetails cliente = customClientDetailsRepository.findByClientId(clientId);

Cadena resourceIds = cliente.getResourceIds().flujo().recoja(Coleccionistas.unirse a(","));

Cadena ámbitos = cliente.getScope().flujo().recoja(Coleccionistas.unirse a(","));

Cadena grantTypes = cliente.getAuthorizedGrantTypes().flujo().recoja(Coleccionistas.unirse a(","));

Cadena autoridades = cliente.getAuthorities().flujo().recoja(Coleccionistas.unirse a(","));

BaseClientDetails base = nuevo BaseClientDetails(cliente.getClientId(), resourceIds, ámbitos, grantTypes, autoridades);

base.setClientSecret(cliente.getClientSecret());

base.setAccessTokenValiditySeconds(cliente.getAccessTokenValiditySeconds());

base.setRefreshTokenValiditySeconds(cliente.getRefreshTokenValiditySeconds());

base.setAdditionalInformation(cliente.getAdditionalInformation());

base.setAutoApproveScopes(cliente.getScope());

devolver base;

}

Tenga en cuenta que estoy utilizando el BaseClientDetails en lugar de implementar la clase DetallesDelCliente interfaz. Parece ser la mejor opción, ya que incluso la implementación estándar de JDBC la utiliza.

Por último, tenemos que cambiar nuestro AuthorizationServerConfig utilizar nuestro CouchbaseClientDetailsService:

@Configuration
@EnableAuthorizationServer
public class AuthorizationServerConfig extends AuthorizationServerConfigurerAdapter {

    @Autowired
    private CouchbaseClientDetailsService couchbaseClientDetailsService;

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

}

@Configuración

@ActivarServidorAutorización

público clase AuthorizationServerConfig extiende AuthorizationServerConfigurerAdapter {

@Autowired

privado CouchbaseClientDetailsService couchbaseClientDetailsService;

@Override

público void configure(ConfiguradorDeDetallesDelCliente configurador) lanza Excepción {

configurador.conDetallesDelCliente(couchbaseClientDetailsService);

}

Este es el aspecto de toda la clase:

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()");
    }

}

importar org.springframework.judías.fábrica.anotación.Autowired;

importar org.springframework.contexto.anotación.Configuración;

importar org.springframework.seguridad.autenticación.AuthenticationManager;

importar org.springframework.seguridad.cripto.contraseña.Codificador de contraseñas;

importar org.springframework.seguridad.oauth2.config.anotación.configuradores.ConfiguradorDeDetallesDelCliente;

importar org.springframework.seguridad.oauth2.config.anotación.web.configuración.AuthorizationServerConfigurerAdapter;

importar org.springframework.seguridad.oauth2.config.anotación.web.configuración.EnableAuthorizationServer;

importar org.springframework.seguridad.oauth2.config.anotación.web.configuradores.AuthorizationServerEndpointsConfigurer;

importar org.springframework.seguridad.oauth2.config.anotación.web.configuradores.AuthorizationServerSecurityConfigurer;

importar org.springframework.seguridad.oauth2.proveedor.ficha.TokenStore;

@Configuración

@ActivarServidorAutorización

público clase AuthorizationServerConfig extiende AuthorizationServerConfigurerAdapter {

@Autowired

privado TokenStore almacén de fichas;

@Autowired

privado AuthenticationManager authenticationManager;

@Autowired

privado CouchbaseClientDetailsService couchbaseClientDetailsService;

@Autowired

privado Codificador de contraseñas codificador de contraseñas;

@Override

público void configure(ConfiguradorDeDetallesDelCliente configurador) lanza Excepción {

configurador.conDetallesDelCliente(couchbaseClientDetailsService);

}

@Override

público void configure(AuthorizationServerEndpointsConfigurer puntos finales) lanza Excepción {

puntos finales.almacén de fichas(almacén de fichas)

.authenticationManager(authenticationManager);

}

@Override

público void configure(

AuthorizationServerSecurityConfigurer oauthServer)

lanza Excepción {

oauthServer

.tokenKeyAccess("permitAll()")

.checkTokenAccess("isAuthenticated()");

}

Ahora puede simplemente insertar un nuevo cliente en su base de datos y utilizar estas credenciales para autenticarse a través de 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 Cadena GRANT_TYPE_PASSWORD = "contraseña";

estático final Cadena CÓDIGO_AUTORIZACIÓN = "authorization_code";

estático final Cadena REFRESH_TOKEN = "refresh_token";

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

estático final Cadena ALCANCE_LEER = "leer";

estático final Cadena SCOPE_WRITE = "escribir";

estático final Cadena CONFÍE EN = "confianza";

privado void createOauthClients() {

CustomClientDetails cliente = nuevo CustomClientDetails();

cliente.setId("someId");

cliente.setResourceIds(nuevo HashSet<>(Matrices.asList("resource_id")) );

cliente.setClientId("android-cliente");

cliente.setClientSecret("android-secret");

cliente.setAuthorizedGrantTypes(nuevo HashSet<>(Matrices.asList(GRANT_TYPE_PASSWORD, CÓDIGO_AUTORIZACIÓN, REFRESH_TOKEN, IMPLÍCITO)));

cliente.setScope(nuevo HashSet<>(Matrices.asList(ALCANCE_LEER, SCOPE_WRITE, CONFÍE EN)));

cliente.setSecretRequired(verdadero);

cliente.setAccessTokenValiditySeconds(50000);

cliente.setRefreshTokenValiditySeconds(50000);

cliente.setScoped(falso);

customClientDetailsRepository.guardar(cliente);

}

TL;DR - El truco está en aplicar el org.springframework.security.oauth2.provider.ClientDetailsService y pasarlo como parámetro a su ConfiguradorDeDetallesDelCliente:

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

@Override

público void configure(ConfiguradorDeDetallesDelCliente configurador) lanza Excepción {

configurador.conDetallesDelCliente(couchbaseClientDetailsService);

}

Si tienes alguna pregunta, envíame un tweet a @deniswsrosa

Denis Rosa, Defensor del Desarrollador, Couchbase

Comparte este artículo

Platform

Self-Managed

Services

Capabilities

Why Couchbase?

Migrate to Capella

By Use Case

By Industry

By Application Need

Popular Docs

By Developer Role

Quickstart

Resource Center

About

Partnerships

Our Services

Partners: Register a Deal

Ready to register a deal with Couchbase?

Marriott

Spring Seguridad y Registro Dinámico de Clientes | OAuth Parte 3

Recibe actualizaciones del blog de Couchbase en tu bandeja de entrada

Autor

Publicado por Denis Rosa, Defensor del Desarrollador, Couchbase

Deja un comentario Cancelar respuesta

¿Listo para empezar con Couchbase Capella?

Empezar a construir

Utilizar Capella gratis

Póngase en contacto