CodeGym /Cursos /Módulo 5. Spring /Configuración avanzada

Configuración avanzada

Módulo 5. Spring

Nivel 18 , Lección 10

Disponible

HttpSecurity.oauth2Login() proporciona una serie de opciones de configuración para configurar la autorización OAuth 2.0. Las principales opciones de configuración están agrupadas por sus contrapartes para los puntos finales del protocolo.

Por ejemplo, oauth2Login().authorizationEndpoint() le permite configurar un punto final de autorización, mientras que oauth2Login().tokenEndpoint() le permite configurar un punto final de token.

El siguiente código muestra un ejemplo:

Configuración de inicio de sesión OAuth2 extendida

Java


@EnableWebSecurity
public class OAuth2LoginSecurityConfig {
	@Bean
	public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
		http
			.oauth2Login(oauth2 -> oauth2
			    .authorizationEndpoint(authorization -> authorization
			            ...
			    )
			    .redirectionEndpoint(redirection -> redirection
			            ...
			    )
			    .tokenEndpoint(token -> token
			            ...
			    )
			    .userInfoEndpoint(userInfo -> userInfo
			            ...
			    )
			);
		return http.build();
	}
}

Kotlin


@EnableWebSecurity
class OAuth2LoginSecurityConfig {
    @Bean
    open fun filterChain(http: HttpSecurity): SecurityFilterChain {
        http {
            oauth2Login {
                authorizationEndpoint {
                    ...
                }
                redirectionEndpoint {
                    ...
                }
                tokenEndpoint {
                    ...
                }
                userInfoEndpoint {
                    ...
                }
            }
        }
        return http.build()
    }
}

El objetivo principal de crear oauth2Login() basado en DSL era coincidir estrechamente con el nombre definido en las especificaciones.

El marco de autorización de OAuth 2.0 define puntos finales de protocolo de la siguiente manera:

El proceso de autorización utiliza dos Puntos finales del servidor de autorización (recursos HTTP):

Punto final de autorización: utilizado por el cliente para obtener la autorización del propietario del recurso a través de la redirección del agente de usuario.
Punto de token final: utilizado por un cliente para intercambiar permiso de acceso por un token de acceso, normalmente al autenticar al cliente.

También un punto final de cliente:

Punto final de reenvío: utilizado por el servidor de autorización para devolver respuestas que contienen credenciales de autorización al cliente a través del agente de usuario propietario del recurso.

La especificación OpenID Connect Core 1.0 define punto final UserInfo de la siguiente manera:

El punto final UserInfo es un recurso OAuth 2.0 protegido, que devuelve información sobre el usuario final autenticado. Para obtener los datos del usuario final solicitados, el cliente realiza una solicitud al punto final UserInfo utilizando el token de acceso obtenido a través de la autenticación OpenID Connect. Estos valores declarados suelen estar representados por un objeto JSON que contiene un conjunto de pares nombre-valor para los valores declarados.

El siguiente código demuestra todas las opciones de configuración disponibles para oauth2Login() basado en DSL:

parámetros de configuración de autorización OAuth2

Java


@EnableWebSecurity
public class OAuth2LoginSecurityConfig {
	@Bean
	public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
		http
			.oauth2Login(oauth2 -> oauth2
			    .clientRegistrationRepository(this.clientRegistrationRepository())
			    .authorizedClientRepository(this.authorizedClientRepository())
			    .authorizedClientService(this.authorizedClientService())
			    .loginPage("/login")
			    .authorizationEndpoint(authorization -> authorization
			        .baseUri(this.authorizationRequestBaseUri())
			        .authorizationRequestRepository(this.authorizationRequestRepository())
			        .authorizationRequestResolver(this.authorizationRequestResolver())
			    )
			    .redirectionEndpoint(redirection -> redirection
			        .baseUri(this.authorizationResponseBaseUri())
			    )
			    .tokenEndpoint(token -> token
			        .accessTokenResponseClient(this.accessTokenResponseClient())
			    )
			    .userInfoEndpoint(userInfo -> userInfo
			        .userAuthoritiesMapper(this.userAuthoritiesMapper())
			        .userService(this.oauth2UserService())
			        .oidcUserService(this.oidcUserService())
			    )
			);
		return http.build();
	}
}

Kotlin


@EnableWebSecurity
class OAuth2LoginSecurityConfig {
    @Bean
    open fun filterChain(http: HttpSecurity): SecurityFilterChain {
        http {
            oauth2Login {
                clientRegistrationRepository = clientRegistrationRepository()
                authorizedClientRepository = authorizedClientRepository()
                authorizedClientService = authorizedClientService()
                loginPage = "/login"
                authorizationEndpoint {
                    baseUri = authorizationRequestBaseUri()
                    authorizationRequestRepository = authorizationRequestRepository()
                    authorizationRequestResolver = authorizationRequestResolver()
                }
                redirectionEndpoint {
                    baseUri = authorizationResponseBaseUri()
                }
                tokenEndpoint {
                    accessTokenResponseClient = accessTokenResponseClient()
                }
                userInfoEndpoint {
                    userAuthoritiesMapper = userAuthoritiesMapper()
                    userService = oauth2UserService()
                    oidcUserService = oidcUserService()
                }
            }
        }
        return http.build()
    }
}

Además de oauth2Login(), la configuración basada en DSL también admite la configuración XML.

El siguiente código muestra todas las opciones de configuración disponibles en espacio de nombres de seguridad:

Opciones de configuración XML de inicio de sesión de OAuth2


<http>
	<oauth2-login client-registration-repository-ref="clientRegistrationRepository"
                  authorized-client-repository-ref="authorizedClientRepository"
                  authorized-client-service-ref="authorizedClientService"
                  authorization-request-repository-ref="authorizationRequestRepository"
                  authorization-request-resolver-ref="authorizationRequestResolver"
                  access-token-response-client-ref="accessTokenResponseClient"
                  user-authorities-mapper-ref="userAuthoritiesMapper"
                  user-service-ref="oauth2UserService"
                  oidc-user-service-ref="oidcUserService"
                  login-processing-url="/login/oauth2/code/*"
                  login-page="/login"
                  authentication-success-handler-ref="authenticationSuccessHandler"
                  authentication-failure-handler-ref="authenticationFailureHandler"
                  jwt-decoder-factory-ref="jwtDecoderFactory"/>
</http>

Las siguientes secciones describen cada una de las opciones de configuración disponibles con más detalle:

Inicio de sesión de página OAuth 2.0
Punto final de redirección
Punto final UserInfo
Verificación de la firma del token de identificación
Cierre de sesión de OpenID Connect 1.0

Página de inicio de sesión de OAuth 2.0

De forma predeterminada, la página de inicio de sesión en OAuth 2.0 se genera automáticamente a través de DefaultLoginPageGeneratingFilter. La página de autorización predeterminada muestra cada cliente OAuth configurado con su ClientRegistration.clientName como un enlace que se puede utilizar para iniciar una solicitud de autorización (o inicio de sesión de OAuth 2.0).

Para que DefaultLoginPageGeneratingFilter muestre enlaces para clientes OAuth configurados, el ClientRegistrationRepository registrado también debe implementar el código Iterable<ClientRegistration>. Consulte InMemoryClientRegistrationRepository como referencia.

La asignación de enlace predeterminada para cada cliente OAuth es la siguiente:

OAuth2AuthorizationRequestRedirectFilter.DEFAULT_AUTHORIZATION_REQUEST_BASE_URI + "/{registrationId} "

La siguiente línea es un ejemplo:

<a href="/oauth2/authorization/google">Google</a>

Para anular la página de inicio de sesión predeterminada, configure oauth2Login().loginPage() y (opcional) oauth2Login().authorizationEndpoint().baseUri().

La siguiente lista es un ejemplo:

Configuración de la página de inicio de sesión de OAuth2

Java

@EnableWebSecurity
public class OAuth2LoginSecurityConfig {
	@Bean
	public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
		http
			.oauth2Login(oauth2 -> oauth2
			    .loginPage("/login/oauth2")
			    ...
			    .authorizationEndpoint(authorization -> authorization
			        .baseUri("/login/oauth2/authorization")
			        ...
			    )
			);
		return http.build();
	}
}

Kotlin


@EnableWebSecurity
class OAuth2LoginSecurityConfig {
    @Bean
    open fun filterChain(http: HttpSecurity): SecurityFilterChain {
        http {
            oauth2Login {
                loginPage = "/login/oauth2"
                authorizationEndpoint {
                    baseUri = "/login/oauth2/authorization"
                }
            }
        }
        return http.build()
    }
}

Xml

<http>
    <oauth2-login login-page="/login/oauth2"
                     ...
    />
</http>

Debe especificar para el parámetro de anotación @Controller @RequestMapping("/login/oauth2"), que puede representar una página de inicio de sesión personalizada.

Como se señaló anteriormente, agregar oauth2Login().authorizationEndpoint().baseUri() a la configuración es opcional. Sin embargo, si elige personalizar su configuración, asegúrese de que cada referencia de cliente OAuth coincida con authorizationEndpoint().baseUri().

La siguiente línea es un ejemplo:

<a href="/login/oauth2/authorization/google">Google</a>

Punto final de redireccionamiento

Se utiliza el punto final de redireccionamiento por el servidor de autorización para devolver una respuesta de autorización (que contiene las credenciales de autorización) al cliente a través del agente de usuario del propietario del recurso.

Usos de inicio de sesión de OAuth 2.0 permiso de contraseña. Por lo tanto, la credencial de autorización es el código de autorización.

La respuesta predeterminada a la solicitud de autorización para baseUri (punto final de reenvío) es /login/oauth2/code/*, que se define en OAuth2LoginAuthenticationFilter.DEFAULT_FILTER_PROCESSES_URI.

Si necesita configurar la respuesta de autorización BaseUri punto final, configúrelo, como se muestra en el siguiente ejemplo:

Configuración del punto final de reenvío

Java


@EnableWebSecurity
public class OAuth2LoginSecurityConfig {
    @Bean
	public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
		http
			.oauth2Login(oauth2 -> oauth2
			    .redirectionEndpoint(redirection -> redirection
			        .baseUri("/login/oauth2/callback/*")
			        ...
			    )
			);
		return http.build();
	}
}

Kotlin


@EnableWebSecurity
class OAuth2LoginSecurityConfig {
    @Bean
    open fun filterChain(http: HttpSecurity): SecurityFilterChain {
        http {
            oauth2Login {
                redirectionEndpoint {
                    baseUri = "/login/oauth2/callback/*"
                }
            }
        }
        return http.build()
    }
}

Xml


<http>
    <oauth2-login login-processing-url="/login/oauth2/callback/*"
                  ...
    />
</http>

También debe asegurarse que ClientRegistration.redirectUri corresponde a una respuesta de solicitud de autorización personalizada para baseUri.

La siguiente lista es un ejemplo:

Java


return CommonOAuth2Provider.GOOGLE.getBuilder("google")
	.clientId("google-client-id")
	.clientSecret("google-client-secret")
	.redirectUri("{baseUrl}/login/oauth2/callback/{registrationId}")
.build();


return CommonOAuth2Provider.GOOGLE.getBuilder("google")
    .clientId("google-client-id")
    .clientSecret("google-client-secret")
    .redirectUri("{baseUrl}/login/oauth2/callback/{registrationId}")
    .build()

Punto final UserInfo

UserInfo El punto final contiene una serie de opciones de configuración, que se describen en las siguientes subsecciones:

Asignación de permisos de usuario
Servicio de usuario de OAuth 2.0
Servicio de usuario de OpenID Connect 1.0

Visualización de permisos de usuario

Después de que el usuario se haya autenticado exitosamente a través de OAuth 2.0 proveedor, OAuth2User.getAuthorities() (o OidcUser.getAuthorities()) se puede asignar a un nuevo conjunto de instancias GrantedAuthority, que serán se pasa a OAuth2AuthenticationToken cuando se completa la autenticación.

OAuth2AuthenticationToken.getAuthorities() se utiliza para autorizar solicitudes, por ejemplo en hasRole('USER') o hasRole('ADMIN').

Hay varias opciones para mostrar los permisos de usuario:

Uso GrantedAuthoritiesMapper
Estrategia basada en delegación utilizando OAuth2UserService

Uso de GrantedAuthoritiesMapper

Especifique la implementación GrantedAuthoritiesMapper y configúrela como se muestra en el siguiente ejemplo:

Configuración del asignador de autoridades otorgadas

Java


@EnableWebSecurity
public class OAuth2LoginSecurityConfig {
    @Bean
	public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
		http
			.oauth2Login(oauth2 -> oauth2
			    .userInfoEndpoint(userInfo -> userInfo
			        .userAuthoritiesMapper(this.userAuthoritiesMapper())
			        ...
			    )
			);
		return http.build();
	}
	private GrantedAuthoritiesMapper userAuthoritiesMapper() {
		return (authorities) -> {
			Set<GrantedAuthority> mappedAuthorities = new HashSet<>();
			authorities.forEach(authority -> {
				if (OidcUserAuthority.class.isInstance(authority)) {
					OidcUserAuthority oidcUserAuthority = (OidcUserAuthority)authority;
					OidcIdToken idToken = oidcUserAuthority.getIdToken();
					OidcUserInfo userInfo = oidcUserAuthority.getUserInfo();
					// Asigna los valores reclamados que se encuentran en idToken y/o userInfo
                    // a una o más GrantedAuthorities y agrégalos a mappedAuthorities
				} else if (OAuth2UserAuthority.class.isInstance(authority)) {
					OAuth2UserAuthority oauth2UserAuthority = (OAuth2UserAuthority)authority;
					Map<String, Object> userAttributes = oauth2UserAuthority.getAttributes();
					// Asigna los atributos encontrados en userAttributes
                    // a una o más GrantedAuthorities y agrégalos a mappedAuthorities
				}
			});
			return mappedAuthorities;
		};
	}
}

Kotlin


@EnableWebSecurity
class OAuth2LoginSecurityConfig {
    @Bean
    open fun filterChain(http: HttpSecurity): SecurityFilterChain {
        http {
            oauth2Login {
                userInfoEndpoint {
                    userAuthoritiesMapper = userAuthoritiesMapper()
                }
            }
        }
        return http.build()
    }
    private fun userAuthoritiesMapper(): GrantedAuthoritiesMapper = GrantedAuthoritiesMapper { authorities: Collection<GrantedAuthority> ->
        val mappedAuthorities = emptySet<GrantedAuthority>()
        authorities.forEach { authority ->
            if (authority is OidcUserAuthority) {
                val idToken = authority.idToken
                val userInfo = authority.userInfo
                // Asigna los valores reclamados que se encuentran en idToken y/o userInfo
                // a una o más GrantedAuthorities y agrégalos a mappedAuthorities
            } else if (authority is OAuth2UserAuthority) {
                val userAttributes = authority.attributes
               	// Asigna los atributos encontrados en userAttributes
                // a una o más GrantedAuthorities y agrégalos a mappedAuthorities
            }
        }
        mappedAuthorities
    }
}}

Xml


<http>
    <oauth2-login user-authorities-mapper-ref="userAuthoritiesMapper"
                  ...
    />
</http>

Como alternativa, puede registrar un @Bean para GrantedAuthoritiesMapper para que se aplique automáticamente a la configuración, como se muestra en el siguiente ejemplo:

Configuración para mostrar permisos adquiridos mediante bean

Java


@EnableWebSecurity
public class OAuth2LoginSecurityConfig {
	@Bean
	public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
		http
		    .oauth2Login(withDefaults());
		return http.build();
	}
	@Bean
	public GrantedAuthoritiesMapper userAuthoritiesMapper() {
		...
	}
}

Kotlin


@EnableWebSecurity
class OAuth2LoginSecurityConfig {
    @Bean
    open fun filterChain(http: HttpSecurity): SecurityFilterChain {
        http {
            oauth2Login { }
        }
        return http.build()
    }
    @Bean
    fun userAuthoritiesMapper(): GrantedAuthoritiesMapper {
        ...
    }
}

Estrategia basada en delegación usando OAuth2UserService

Esta estrategia es más avanzada que usar GrantedAuthoritiesMapper, sin embargo, también es más flexible porque Da acceso a OAuth2UserRequest y OAuth2User (cuando se usa OAuth 2.0 UserService) o OidcUserRequest y OidcUser (cuando se usa OpenID Connect 1.0 UserService).

OAuth2UserRequest (y OidcUserRequest) proporciona acceso al OAuth2AccessToken asociado, que es muy útil en casos en los que el delegador necesita obtener información de permisos de un recurso protegido antes de poder mostrar permisos personalizados al usuario.

El siguiente ejemplo muestra cómo implementar y configurar una estrategia basada en delegación utilizando OpenID Connect 1.0 UserService:

Configuración de OAuth2UserService

Java

 
@EnableWebSecurity
public class OAuth2LoginSecurityConfig {
	@Bean
	public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
		http
			.oauth2Login(oauth2 -> oauth2
			    .userInfoEndpoint(userInfo -> userInfo
			        .oidcUserService(this.oidcUserService())
			        ...
			    )
			);
		return http.build();
	}
	private OAuth2UserService<OidcUserRequest, OidcUser> oidcUserService() {
		final OidcUserService delegate = new OidcUserService();
		return (userRequest) -> {
			// Delegar los poderes de la implementación estándar para cargar el usuario
			OidcUser oidcUser = delegate.loadUser(userRequest);
			OAuth2AccessToken accessToken = userRequest.getAccessToken();
			Set<GrantedAuthority> mappedAuthorities = new HashSet<>();
			// TODO
            // 1) Delegar los poderes de la implementación estándar para cargar el usuario
            // 2) Asigne la información de autoridad a una o más GrantedAuthorities y agréguela a mappedAuthorities
            // 3) Cree una copia de oidcUser, pero use mappedAuthorities
			oidcUser = new DefaultOidcUser(mappedAuthorities, oidcUser.getIdToken(), oidcUser.getUserInfo());
			return oidcUser;
		};
	}
}

Kotlin


@EnableWebSecurity
class OAuth2LoginSecurityConfig  {
    @Bean
    open fun filterChain(http: HttpSecurity): SecurityFilterChain {
        http {
            oauth2Login {
                userInfoEndpoint {
                    oidcUserService = oidcUserService()
                }
            }
        }
        return http.build()
    }
    @Bean
    fun oidcUserService(): OAuth2UserService<OidcUserRequest, OidcUser> {
        val delegate = OidcUserService()
        return OAuth2UserService { userRequest ->
            // Delegar los poderes de la implementación estándar para cargar el usuario
            var oidcUser = delegate.loadUser(userRequest)
            val accessToken = userRequest.accessToken
            val mappedAuthorities = HashSet<GrantedAuthority>()
            // TODO
            // 1) Delegar los poderes de la implementación estándar para cargar el usuario
            // 2) Asigne la información de autoridad a una o más GrantedAuthorities y agréguela a mappedAuthorities
            // 3) Cree una copia de oidcUser, pero use mappedAuthorities
            oidcUser = DefaultOidcUser(mappedAuthorities, oidcUser.idToken, oidcUser.userInfo)
            oidcUser
        }
    }
}

Xml

<http>
    <oauth2-login oidc-user-service-ref="oidcUserService"
                  ...
    />
</http>

OAuth 2.0 UserService

DefaultOAuth2UserService es una implementación de OAuth2UserService, que admite proveedores estándar de OAuth 2.0.

OAuth2UserService recupera los atributos de usuario del usuario final (recurso propietario) desde el punto final UserInfo (utilizando el token de acceso proporcionado al cliente durante el flujo de autorización) y devuelve AuthenticatedPrincipal en el formato OAuth2User.

DefaultOAuth2UserService utiliza RestOperations cuando solicita atributos personalizados en el punto final UserInfo.

Si desea configurar el procesamiento previo de solicitudes de UserInfo, puede pasar DefaultOAuth2UserService.setRequestEntityConverter() con Convertidor<OAuth2UserRequest, RequestEntity<?>> personalizado. La implementación estándar de OAuth2UserRequestEntityConverter crea una representación RequestEntity de la solicitud UserInfo, que de forma predeterminada establece OAuth2AccessToken en Authorization header.

Por otro lado, si necesita configurar el posprocesamiento de la respuesta UserInfo, deberá pasar DefaultOAuth2UserService.setRestOperations() con un configurado personalizado RestOperaciones. Las RestOperations están configuradas de la siguiente manera de forma predeterminada:

RestTemplate restTemplate = new RestTemplate(); restTemplate.setErrorHandler(new
        OAuth2ErrorResponseErrorHandler());

OAuth2ErrorResponseErrorHandler es un ResponseErrorHandler que puede manejar Error de OAuth 2.0 (400 solicitud incorrecta). Utiliza OAuth2ErrorHttpMessageConverter para convertir los parámetros de error de OAuth 2.0 a OAuth2Error.

Ya sea que configure DefaultOAuth2UserService o pase su propio implementación de OAuth2UserService, deberá configurarla como se muestra en el siguiente ejemplo:

Java


@EnableWebSecurity
public class OAuth2LoginSecurityConfig {
	@Bean
	public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
		http
			.oauth2Login(oauth2 -> oauth2
			    .userInfoEndpoint(userInfo -> userInfo
			        .userService(this.oauth2UserService())
			        ...
			    )
			);
		return http.build();
	}
	private OAuth2UserService<OAuth2UserRequest, OAuth2User> oauth2UserService() {
		...
	}
}

Kotlin


@EnableWebSecurity
class OAuth2LoginSecurityConfig {
    @Bean
    open fun filterChain(http: HttpSecurity): SecurityFilterChain {
        http {
            oauth2Login {
                userInfoEndpoint {
                    userService = oauth2UserService()
                    // ...
                }
            }
        }
        return http.build()
    }
    private fun oauth2UserService(): OAuth2UserService<OAuth2UserRequest, OAuth2User> {
        // ...
    }
}

OpenID Connect 1.0 UserService

OidcUserService es una implementación de OAuth2UserService que admite el proveedor OpenID Connect 1.0.

OidcUserService utiliza DefaultOAuth2UserService al solicitar atributos personalizados en un endpoint UserInfo.

Si necesita configurar el preprocesamiento de la solicitud UserInfo y/o el posprocesamiento de la respuesta UserInfo, deberá pasar OidcUserService.setOauth2UserService() con un DefaultOAuth2UserService configurado personalizado.

Ya sea que configure OidcUserService o pase su propia implementación de OAuth2UserService para el proveedor OpenID Connect 1.0 , deberá configurarlo como se muestra en el siguiente ejemplo:

Java


@EnableWebSecurity
public class OAuth2LoginSecurityConfig {
	@Bean
	public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
		http
			.oauth2Login(oauth2 -> oauth2
				.userInfoEndpoint(userInfo -> userInfo
				    .oidcUserService(this.oidcUserService())
				    ...
			    )
			);
		return http.build();
	}
	private OAuth2UserService<OidcUserRequest, OidcUser> oidcUserService() {
		...
	}
}

Kotlin


@EnableWebSecurity
class OAuth2LoginSecurityConfig {
    @Bean
    open fun filterChain(http: HttpSecurity): SecurityFilterChain {
        http {
            oauth2Login {
                userInfoEndpoint {
                    oidcUserService = oidcUserService()
                    // ...
                }
            }
        }
        return http.build()
    }
    private fun oidcUserService(): OAuth2UserService<OidcUserRequest, OidcUser> {
        // ...
    }
}

Verificación de firma de token de ID

La autenticación OpenID Connect 1.0 proporciona un token de ID , que es un token de seguridad que contiene los valores de autenticación reclamados por el usuario final del servidor de autorización cuando lo utiliza el cliente.

El token de ID se representa como un token web JSON (JWT) y DEBE firmarse con Firmas web JSON (JWS).

OidcIdTokenDecoderFactory proporciona JwtDecoder, utilizado para verificar la firma OidcIdToken. El algoritmo predeterminado es RS256, pero puede ser diferente si lo asigna durante el registro del cliente. En tales casos, el solucionador se puede configurar para devolver el algoritmo esperado para JWS asignado a un cliente específico.

El solucionador de algoritmo para JWS es una Function que acepta un ClientRegistration y devuelve el JwsAlgorithm esperado para el cliente, como SignatureAlgorithm.RS256 o MacAlgorithm.HS256.

El siguiente código demuestra cómo configurar @Bean para OidcIdTokenDecoderFactory, que por defecto será MacAlgorithm.HS256 para todos los ClientRegistration:

Java


@Bean
public JwtDecoderFactory<ClientRegistration> idTokenDecoderFactory() {
    OidcIdTokenDecoderFactory
    idTokenDecoderFactory = new OidcIdTokenDecoderFactory(); idTokenDecoderFactory.setJwsAlgorithmResolver(clientRegistration -> MacAlgorithm.HS256);
    return idTokenDecoderFactory;
}

Kotlin


@Bean
fun idTokenDecoderFactory(): JwtDecoderFactory<ClientRegistration?> {
    val idTokenDecoderFactory = OidcIdTokenDecoderFactory()
    idTokenDecoderFactory.setJwsAlgorithmResolver { MacAlgorithm.HS256 }
    return idTokenDecoderFactory
}

Para algoritmos basados en MAC como HS256, HS384 o HS512, client-secret se utiliza como clave simétrica para la verificación de firmas correspondiente a client-id.

Si hay más de uno configurado para OpenID Connect 1.0 autenticación ClientRegistration, el solucionador de algoritmos para JWS puede evaluar el ClientRegistration pasado para determinar qué algoritmo devolver.

Cierre de sesión de OpenID Connect 1.0

OpenID Connect Session Management 1.0 proporciona la capacidad de registrar el cierre de sesión del usuario final en el lado del proveedor utilizando el cliente. Una de las estrategias disponibles es cierre de sesión iniciado por RP.

Si el proveedor OpenID admite tanto la gestión de sesiones como el descubrimiento, el cliente puede recibir URL del endpoint end_session_endpoint de metadatos de descubrimiento de el proveedor de OpenID. Esto se puede lograr configurando ClientRegistration con issuer-uri, como se muestra en el siguiente ejemplo:


spring:
  security:
    oauth2:
      client:
        registration:
          okta:
            client-id: okta-client-id
            client-secret: okta-client-secret
            ...
        provider:
          okta:
            issuer-uri: https://dev-1234.oktapreview.com

...y OidcClientInitiatedLogoutSuccessHandler, que implementa el cierre de sesión iniciado por el cliente, se pueden configurar de la siguiente manera:

Java


@EnableWebSecurity
public class OAuth2LoginSecurityConfig {
	@Autowired
	private ClientRegistrationRepository clientRegistrationRepository;
	@Bean
	public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
		http
			.authorizeHttpRequests(authorize -> authorize
				.anyRequest().authenticated()
			)
			.oauth2Login(withDefaults())
			.logout(logout -> logout
				.logoutSuccessHandler(oidcLogoutSuccessHandler())
			);
		return http.build();
	}
	private LogoutSuccessHandler oidcLogoutSuccessHandler() {
		OidcClientInitiatedLogoutSuccessHandler oidcLogoutSuccessHandler =
				new OidcClientInitiatedLogoutSuccessHandler(this.clientRegistrationRepository);
		// Establece la ubicación a la que se redirigirá el agente de usuario final
        // después de cerrar sesión en el lado del proveedor
		oidcLogoutSuccessHandler.setPostLogoutRedirectUri("{baseUrl}");
		return oidcLogoutSuccessHandler;
	}
}

Kotlin


@EnableWebSecurity
class OAuth2LoginSecurityConfig {
    @Autowired
    private lateinit var clientRegistrationRepository: ClientRegistrationRepository
    @Bean
    open fun filterChain(http: HttpSecurity): SecurityFilterChain {
        http {
            authorizeRequests {
                authorize(anyRequest, authenticated)
            }
            oauth2Login { }
            logout {
                logoutSuccessHandler = oidcLogoutSuccessHandler()
            }
        }
        return http.build()
    }
    private fun oidcLogoutSuccessHandler(): LogoutSuccessHandler {
        val oidcLogoutSuccessHandler = OidcClientInitiatedLogoutSuccessHandler(clientRegistrationRepository)
        // Establece la ubicación a la que se redirigirá el agente de usuario final
        // después de cerrar sesión en el lado del proveedor
        oidcLogoutSuccessHandler.setPostLogoutRedirectUri("{baseUrl}")
        return oidcLogoutSuccessHandler
    }
}

OidcClientInitiatedLogoutSuccessHandler admite el marcador de posición {baseUrl}. En caso de usando la URL principal de la aplicación, como app.example.org, la reemplazará en el momento de la solicitud.

Anterior Lección anterior

Siguiente Siguiente lección

Comentarios

TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION