执行单点注销

除了其其他注销机制之外，Spring Security 还支持 RP 和 AP 发起的 SAML 2.0 单点注销。

简而言之，Spring Security 支持两种用例

  • **RP 发起** - 您的应用程序有一个端点，当向其发送 POST 请求时，将注销用户并向断言方发送一个 saml2:LogoutRequest。此后，断言方将发送回 saml2:LogoutResponse 并允许您的应用程序做出响应

  • **AP 发起** - 您的应用程序有一个端点，将接收来自断言方的 saml2:LogoutRequest。您的应用程序将在此时完成注销，然后向断言方发送 saml2:LogoutResponse。

在 **AP 发起** 场景中，应用程序在注销后执行的任何本地重定向都将变得毫无意义。一旦您的应用程序发送了 saml2:LogoutResponse，它便不再控制浏览器。

单点注销的最小配置

要使用 Spring Security 的 SAML 2.0 单点注销功能，您需要以下内容

  • 首先，断言方必须支持 SAML 2.0 单点注销

  • 其次，应将断言方配置为签名并 POST saml2:LogoutRequest 和 saml2:LogoutResponse 到您的应用程序的 /logout/saml2/slo 端点

  • 第三，您的应用程序必须具有用于签名 saml2:LogoutRequest 和 saml2:LogoutResponse 的 PKCS#8 私钥和 X.509 证书

您可以在 Spring Boot 中通过以下方式实现此目的

spring:
  security:
    saml2:
      relyingparty:
        registration:
          metadata:
            signing.credentials: (3)
              - private-key-location: classpath:credentials/rp-private.key
                certificate-location: classpath:credentials/rp-certificate.crt
            singlelogout.url: "{baseUrl}/logout/saml2/slo" (2)
            assertingparty:
              metadata-uri: https://ap.example.com/metadata (1)
1 - IDP 的元数据 URI，它将向您的应用程序指示其对 SLO 的支持
2 - 您应用程序中的 SLO 端点
3 - 用于签名 <saml2:LogoutRequest> 和 <saml2:LogoutResponse> 的签名凭据 
An asserting party supports Single Logout if their metadata includes the `<SingleLogoutService>` element in their metadata.

就是这样！

Spring Security 的注销支持提供了许多配置点。请考虑以下用例

启动预期

当使用这些属性时，除了登录之外，SAML 2.0 服务提供商还将自动配置自身以通过 <saml2:LogoutRequest> 和 <saml2:LogoutResponse> 使用 RP 或 AP 发起的注销来促进注销。

它是通过确定性的启动过程实现的

  1. 查询标识服务器元数据端点以获取 <SingleLogoutService> 元素

  2. 扫描元数据并缓存任何公共签名验证密钥

  3. 准备相应的端点

此过程的结果是，标识服务器必须处于活动状态并接收请求，以便服务提供商成功启动。

如果服务提供商查询标识服务器时它已关闭（在适当的超时时间内），则启动将失败。

运行时预期

根据上述配置，任何已登录的用户都可以向您的应用程序发送 POST /logout 以执行 RP 发起的 SLO。然后，您的应用程序将执行以下操作

  1. 注销用户并使会话失效

  2. 生成 <saml2:LogoutRequest> 并将其 POST 到关联的断言方的 SLO 端点

  3. 然后，如果断言方使用 <saml2:LogoutResponse> 响应，则应用程序将对其进行验证并重定向到已配置的成功端点

此外，当断言方将<saml2:LogoutRequest>发送到/logout/saml2/slo时，您的应用程序可以参与AP发起的注销。发生这种情况时，您的应用程序将执行以下操作

  1. 验证<saml2:LogoutRequest>

  2. 注销用户并使会话失效

  3. 生成<saml2:LogoutResponse>并将其POST回断言方的SLO端点

无启动的最小配置

除了启动属性之外，您还可以通过直接发布bean来实现相同的结果，如下所示

  • Java

  • Kotlin

@Configuration
public class SecurityConfig {
    @Value("${private.key}") RSAPrivateKey key;
    @Value("${public.certificate}") X509Certificate certificate;

    @Bean
    RelyingPartyRegistrationRepository registrations() {
        Saml2X509Credential credential = Saml2X509Credential.signing(key, certificate);
        RelyingPartyRegistration registration = RelyingPartyRegistrations
                .fromMetadataLocation("https://ap.example.org/metadata") (1)
                .registrationId("metadata")
                .singleLogoutServiceLocation("{baseUrl}/logout/saml2/slo") (2)
                .signingX509Credentials((signing) -> signing.add(credential)) (3)
                .build();
        return new InMemoryRelyingPartyRegistrationRepository(registration);
    }

    @Bean
    SecurityFilterChain web(HttpSecurity http) throws Exception {
        http
            .authorizeHttpRequests((authorize) -> authorize
                .anyRequest().authenticated()
            )
            .saml2Login(withDefaults())
            .saml2Logout(withDefaults()); (4)

        return http.build();
    }
}
@Configuration
class SecurityConfig(@Value("${private.key}") val key: RSAPrivateKey,
        @Value("${public.certificate}") val certificate: X509Certificate) {

    @Bean
    fun registrations(): RelyingPartyRegistrationRepository {
        val credential = Saml2X509Credential.signing(key, certificate)
        val registration = RelyingPartyRegistrations
                .fromMetadataLocation("https://ap.example.org/metadata") (1)
                .registrationId("metadata")
                .singleLogoutServiceLocation("{baseUrl}/logout/saml2/slo") (2)
                .signingX509Credentials({ signing: List<Saml2X509Credential> -> signing.add(credential) }) (3)
                .build()
        return InMemoryRelyingPartyRegistrationRepository(registration)
    }

    @Bean
    fun web(http: HttpSecurity): SecurityFilterChain {
        http {
            authorizeHttpRequests {
                anyRequest = authenticated
            }
            saml2Login {

            }
            saml2Logout { (4)

            }
        }

        return http.build()
    }
}
1 - IDP 的元数据 URI，它将向您的应用程序指示其对 SLO 的支持
2 - 您应用程序中的 SLO 端点
3 - 用于签署<saml2:LogoutRequest>和<saml2:LogoutResponse>的签名凭据，您也可以将其添加到多个依赖方
4 - 其次，指示您的应用程序希望使用SAML SLO注销最终用户
添加saml2Logout为您的服务提供者整体添加了注销功能。因为它是一个可选功能，您需要为每个单独的RelyingPartyRegistration启用它。您可以通过设置RelyingPartyRegistration.Builder#singleLogoutServiceLocation属性来实现，如上所示。

Saml 2.0注销的工作原理

接下来，让我们了解Spring Security用于支持基于servlet的应用程序（例如我们刚刚看到的应用程序）中的SAML 2.0注销的体系结构组件。

对于RP发起的注销

number 1 Spring Security执行其注销流程，调用其LogoutHandler使会话失效并执行其他清理操作。然后，它调用Saml2RelyingPartyInitiatedLogoutSuccessHandler。

number 2 注销成功处理程序使用Saml2LogoutRequestResolver的实例来创建、签署和序列化<saml2:LogoutRequest>。它使用来自与当前Saml2AuthenticatedPrincipal关联的RelyingPartyRegistration的密钥和配置。然后，它将<saml2:LogoutRequest>重定向发布到断言方SLO端点

浏览器将控制权交给断言方。如果断言方重定向回（它可能不会），则应用程序继续执行步骤number 3。

number 3 Saml2LogoutResponseFilter使用其Saml2LogoutResponseValidator反序列化、验证和处理<saml2:LogoutResponse>。

number 4 如果有效，则它通过重定向到/login?logout或任何已配置的内容来完成本地注销流程。如果无效，则响应400。

对于AP发起的注销

number 1 Saml2LogoutRequestFilter使用其Saml2LogoutRequestValidator反序列化、验证和处理<saml2:LogoutRequest>。

number 2 如果有效，则过滤器将调用已配置的LogoutHandler，使会话失效并执行其他清理操作。

number 3 它使用Saml2LogoutResponseResolver创建、签署和序列化<saml2:LogoutResponse>。它使用来自从端点派生的RelyingPartyRegistration或来自<saml2:LogoutRequest>内容的密钥和配置。然后，它将<saml2:LogoutResponse>重定向发布到断言方SLO端点。

浏览器将控制权交给断言方。

number 4 如果无效，则它响应400。

配置注销端点

可以通过不同的端点触发三种行为

  • RP发起的注销，允许经过身份验证的用户POST并通过向断言方发送<saml2:LogoutRequest>来触发注销过程

  • AP发起的注销，允许断言方向应用程序发送<saml2:LogoutRequest>

  • AP注销响应，允许断言方响应RP发起的<saml2:LogoutRequest>发送<saml2:LogoutResponse>

第一个是当主体类型为Saml2AuthenticatedPrincipal时，通过执行正常的POST /logout触发的。

第二个是通过使用断言方签名的SAMLRequest向/logout/saml2/slo端点发布POST触发的。

第三个是通过使用断言方签名的SAMLResponse向/logout/saml2/slo端点发布POST触发的。

因为用户已经登录或原始注销请求已知，所以registrationId已知。因此，默认情况下，{registrationId}不是这些URL的一部分。

此URL可在DSL中自定义。

例如，如果您正在将现有的依赖方迁移到Spring Security，则您的断言方可能已经指向GET /SLOService.saml2。为了减少断言方配置的变化，您可以在DSL中配置过滤器，如下所示

  • Java

  • Kotlin

http
    .saml2Logout((saml2) -> saml2
        .logoutRequest((request) -> request.logoutUrl("/SLOService.saml2"))
        .logoutResponse((response) -> response.logoutUrl("/SLOService.saml2"))
    );
http {
    saml2Logout {
        logoutRequest {
            logoutUrl = "/SLOService.saml2"
        }
        logoutResponse {
            logoutUrl = "/SLOService.saml2"
        }
    }
}

您还应该在您的RelyingPartyRegistration中配置这些端点。

此外，您可以自定义在本地触发注销的端点，如下所示

  • Java

  • Kotlin

http
    .saml2Logout((saml2) -> saml2.logoutUrl("/saml2/logout"));
http {
    saml2Logout {
        logoutUrl = "/saml2/logout"
    }
}

将本地注销与SAML 2.0注销分离

在某些情况下，您可能希望为本地注销公开一个注销端点，为RP发起的SLO公开另一个注销端点。就像其他注销机制一样，您可以注册多个端点，只要它们每个都有不同的端点即可。

因此，例如，您可以像这样连接DSL

  • Java

  • Kotlin

http
    .logout((logout) -> logout.logoutUrl("/logout"))
    .saml2Logout((saml2) -> saml2.logoutUrl("/saml2/logout"));
http {
    logout {
        logoutUrl = "/logout"
    }
    saml2Logout {
        logoutUrl = "/saml2/logout"
    }
}

现在，如果客户端发送POST /logout，则会话将被清除，但不会向断言方发送<saml2:LogoutRequest>。但是，如果客户端发送POST /saml2/logout，则应用程序将像往常一样启动SAML 2.0 SLO。

自定义<saml2:LogoutRequest>解析

通常需要在<saml2:LogoutRequest>中设置除Spring Security提供的默认值以外的其他值。

默认情况下，Spring Security将发出<saml2:LogoutRequest>并提供

  • Destination属性 - 来自RelyingPartyRegistration#getAssertingPartyDetails#getSingleLogoutServiceLocation

  • ID属性 - GUID

  • <Issuer>元素 - 来自RelyingPartyRegistration#getEntityId

  • <NameID>元素 - 来自Authentication#getName

要添加其他值，您可以使用委托，如下所示

  • Java

  • Kotlin

@Bean
Saml2LogoutRequestResolver logoutRequestResolver(RelyingPartyRegistrationRepository registrations) {
	OpenSaml4LogoutRequestResolver logoutRequestResolver =
			new OpenSaml4LogoutRequestResolver(registrations);
	logoutRequestResolver.setParametersConsumer((parameters) -> {
		String name = ((Saml2AuthenticatedPrincipal) parameters.getAuthentication().getPrincipal()).getFirstAttribute("CustomAttribute");
		String format = "urn:oasis:names:tc:SAML:2.0:nameid-format:transient";
		LogoutRequest logoutRequest = parameters.getLogoutRequest();
		NameID nameId = logoutRequest.getNameID();
		nameId.setValue(name);
		nameId.setFormat(format);
	});
	return logoutRequestResolver;
}
@Bean
open fun logoutRequestResolver(registrations:RelyingPartyRegistrationRepository?): Saml2LogoutRequestResolver {
    val logoutRequestResolver = OpenSaml4LogoutRequestResolver(registrations)
    logoutRequestResolver.setParametersConsumer { parameters: LogoutRequestParameters ->
        val name: String = (parameters.getAuthentication().getPrincipal() as Saml2AuthenticatedPrincipal).getFirstAttribute("CustomAttribute")
        val format = "urn:oasis:names:tc:SAML:2.0:nameid-format:transient"
        val logoutRequest: LogoutRequest = parameters.getLogoutRequest()
        val nameId: NameID = logoutRequest.getNameID()
        nameId.setValue(name)
        nameId.setFormat(format)
    }
    return logoutRequestResolver
}

然后，您可以在DSL中提供自定义的Saml2LogoutRequestResolver，如下所示

  • Java

  • Kotlin

http
    .saml2Logout((saml2) -> saml2
        .logoutRequest((request) -> request
            .logoutRequestResolver(this.logoutRequestResolver)
        )
    );
http {
    saml2Logout {
        logoutRequest {
            logoutRequestResolver = this.logoutRequestResolver
        }
    }
}

自定义<saml2:LogoutResponse>解析

通常需要在<saml2:LogoutResponse>中设置除Spring Security提供的默认值以外的其他值。

默认情况下，Spring Security将发出<saml2:LogoutResponse>并提供

  • Destination属性 - 来自RelyingPartyRegistration#getAssertingPartyDetails#getSingleLogoutServiceResponseLocation

  • ID属性 - GUID

  • <Issuer>元素 - 来自RelyingPartyRegistration#getEntityId

  • <Status>元素 - SUCCESS

要添加其他值，您可以使用委托，如下所示

  • Java

  • Kotlin

@Bean
public Saml2LogoutResponseResolver logoutResponseResolver(RelyingPartyRegistrationRepository registrations) {
	OpenSaml4LogoutResponseResolver logoutRequestResolver =
			new OpenSaml4LogoutResponseResolver(registrations);
	logoutRequestResolver.setParametersConsumer((parameters) -> {
		if (checkOtherPrevailingConditions(parameters.getRequest())) {
			parameters.getLogoutRequest().getStatus().getStatusCode().setCode(StatusCode.PARTIAL_LOGOUT);
		}
	});
	return logoutRequestResolver;
}
@Bean
open fun logoutResponseResolver(registrations: RelyingPartyRegistrationRepository?): Saml2LogoutResponseResolver {
    val logoutRequestResolver = OpenSaml4LogoutResponseResolver(registrations)
    logoutRequestResolver.setParametersConsumer { LogoutResponseParameters parameters ->
        if (checkOtherPrevailingConditions(parameters.getRequest())) {
            parameters.getLogoutRequest().getStatus().getStatusCode().setCode(StatusCode.PARTIAL_LOGOUT)
        }
    }
    return logoutRequestResolver
}

然后，您可以在DSL中提供自定义的Saml2LogoutResponseResolver，如下所示

  • Java

  • Kotlin

http
    .saml2Logout((saml2) -> saml2
        .logoutRequest((request) -> request
            .logoutRequestResolver(this.logoutRequestResolver)
        )
    );
http {
    saml2Logout {
        logoutRequest {
            logoutRequestResolver = this.logoutRequestResolver
        }
    }
}

自定义<saml2:LogoutRequest>身份验证

要自定义验证，您可以实现自己的Saml2LogoutRequestValidator。此时，验证是最小的，因此您可能首先可以委托给默认的Saml2LogoutRequestValidator，如下所示

  • Java

  • Kotlin

@Component
public class MyOpenSamlLogoutRequestValidator implements Saml2LogoutRequestValidator {
	private final Saml2LogoutRequestValidator delegate = new OpenSamlLogoutRequestValidator();

	@Override
    public Saml2LogoutRequestValidator logout(Saml2LogoutRequestValidatorParameters parameters) {
		 // verify signature, issuer, destination, and principal name
		Saml2LogoutValidatorResult result = delegate.authenticate(authentication);

		LogoutRequest logoutRequest = // ... parse using OpenSAML
        // perform custom validation
    }
}
@Component
open class MyOpenSamlLogoutRequestValidator: Saml2LogoutRequestValidator {
	private val delegate = OpenSamlLogoutRequestValidator()

	@Override
    fun logout(parameters: Saml2LogoutRequestValidatorParameters): Saml2LogoutRequestValidator {
		 // verify signature, issuer, destination, and principal name
		val result = delegate.authenticate(authentication)

		val logoutRequest: LogoutRequest = // ... parse using OpenSAML
        // perform custom validation
    }
}

然后，您可以在DSL中提供自定义的Saml2LogoutRequestValidator，如下所示

  • Java

  • Kotlin

http
    .saml2Logout((saml2) -> saml2
        .logoutRequest((request) -> request
            .logoutRequestValidator(myOpenSamlLogoutRequestValidator)
        )
    );
http {
    saml2Logout {
        logoutRequest {
            logoutRequestValidator = myOpenSamlLogoutRequestValidator
        }
    }
}

自定义<saml2:LogoutResponse>身份验证

要自定义验证，您可以实现自己的Saml2LogoutResponseValidator。此时，验证是最小的，因此您可能首先可以委托给默认的Saml2LogoutResponseValidator，如下所示

  • Java

  • Kotlin

@Component
public class MyOpenSamlLogoutResponseValidator implements Saml2LogoutResponseValidator {
	private final Saml2LogoutResponseValidator delegate = new OpenSamlLogoutResponseValidator();

	@Override
    public Saml2LogoutValidatorResult logout(Saml2LogoutResponseValidatorParameters parameters) {
		// verify signature, issuer, destination, and status
		Saml2LogoutValidatorResult result = delegate.authenticate(parameters);

		LogoutResponse logoutResponse = // ... parse using OpenSAML
        // perform custom validation
    }
}
@Component
open class MyOpenSamlLogoutResponseValidator: Saml2LogoutResponseValidator {
	private val delegate = OpenSamlLogoutResponseValidator()

	@Override
    fun logout(parameters: Saml2LogoutResponseValidatorParameters): Saml2LogoutResponseValidator {
		// verify signature, issuer, destination, and status
		val result = delegate.authenticate(authentication)

		val logoutResponse: LogoutResponse = // ... parse using OpenSAML
        // perform custom validation
    }
}

然后，您可以在DSL中提供自定义的Saml2LogoutResponseValidator，如下所示

  • Java

  • Kotlin

http
    .saml2Logout((saml2) -> saml2
        .logoutResponse((response) -> response
            .logoutResponseAuthenticator(myOpenSamlLogoutResponseAuthenticator)
        )
    );
http {
    saml2Logout {
        logoutResponse {
            logoutResponseValidator = myOpenSamlLogoutResponseValidator
        }
    }
}

自定义<saml2:LogoutRequest>存储

当您的应用程序发送<saml2:LogoutRequest>时，该值将存储在会话中，以便可以验证RelayState参数和<saml2:LogoutResponse>中的InResponseTo属性。

如果要将注销请求存储在会话以外的其他位置，则可以在DSL中提供自定义实现，如下所示

  • Java

  • Kotlin

http
    .saml2Logout((saml2) -> saml2
        .logoutRequest((request) -> request
            .logoutRequestRepository(myCustomLogoutRequestRepository)
        )
    );
http {
    saml2Logout {
        logoutRequest {
            logoutRequestRepository = myCustomLogoutRequestRepository
        }
    }
}

其他与注销相关的参考