遗留Spring MVC(SSR)集成Auth0：静默SSO、SLO实现及SPA SDK适配问询

核心疑问解答 #

1. 是否可/应使用Auth0 SPA JS SDK？ #

不推荐在你的SSR+服务器端会话架构中使用Auth0 SPA JS SDK：

• SPA JS SDK专为单页应用设计，依赖客户端存储（如localStorage）管理令牌，与你基于JSESSIONID的服务器端会话认证模型完全冲突。
• CDN版本本身可靠，但场景不匹配，Auth0官方推荐服务器端应用采用OAuth2授权码流方案，而非客户端侧的SPA SDK。

2. 如何实现跨应用静默SSO？ #

仅重定向到/oauth2/authorization/auth0无法实现静默SSO，必须添加prompt=none参数：

• 正常重定向会触发Auth0登录页，而prompt=none会让Auth0检查浏览器中已有的Auth0会话：
  • 若会话存在，Auth0直接返回授权码，后端完成认证并创建服务器端会话；
  • 若会话不存在，Auth0返回login_required错误，此时需引导用户进入正常登录流程。
• 实现方式：通过自定义AuthorizationRequestResolver在Spring Security的授权请求中拼接该参数。

3. 如何处理跨应用单点注销（SLO）？ #

需要结合Auth0的SLO机制和Spring MVC的会话管理：

1. Auth0端配置：在Auth0控制台为每个应用配置Allowed Logout URLs，开启单点注销功能并设置注销回调URL（如https://app1.example.com/logout/callback）。
2. 应用端处理：
   • 用户主动注销时，后端先重定向到Auth0的注销端点：https://{your-auth0-domain}/v2/logout?client_id={clientId}&returnTo={logout-success-url}，触发Auth0向所有已登录应用发送注销通知。
   • 实现注销回调端点，接收Auth0的SLO请求，根据用户唯一标识（sub）查找并失效所有关联的服务器端会话。需用分布式存储（如Redis）维护sub与JSESSIONID的映射，因为内存会话无法跨应用共享。

4. Auth0推荐的架构方案 #

针对你的SSR、服务器端认证、LDAP+Auth0混合登录、多租户场景，推荐服务器端授权码流架构，结合Spring Security 5的OAuth2 Client模块：

• 认证层：用Auth0托管式通用登录替代或集成原有LDAP（将LDAP作为Auth0的身份源），通过授权码流获取令牌，后端创建并管理服务器端会话。
• 多租户路由：在Auth0中配置多租户，自定义ID Token的租户声明（如tenant_id），Spring MVC应用根据该声明路由到对应租户的资源。
• SSO与SLO：按上述第2、3点的方案实现静默SSO和跨应用单点注销。

明确配置指导 #

SPA SDK适用性结论 #

完全不适用，你的架构属于服务器端应用，应采用Auth0官方推荐的OAuth2授权码流服务器端集成方案。

Auth0托管式通用登录实现 #

在Spring Security中配置OAuth2 Client，对接Auth0的授权、令牌、用户信息端点：

@Configuration
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {
    @Value("${auth0.domain}")
    private String auth0Domain;

    @Value("${auth0.client-id}")
    private String clientId;

    @Value("${auth0.client-secret}")
    private String clientSecret;

    @Value("${auth0.redirect-uri}")
    private String redirectUri;

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.authorizeRequests()
                .anyRequest().authenticated()
                .and()
                .oauth2Login()
                .authorizationEndpoint()
                .authorizationRequestResolver(new CustomAuth0AuthorizationRequestResolver(auth0Domain, clientId))
                .and()
                .userInfoEndpoint()
                .userService(customOAuth2UserService); // 自定义服务加载租户元数据
    }

    @Bean
    public ClientRegistrationRepository clientRegistrationRepository() {
        return new InMemoryClientRegistrationRepository(auth0ClientRegistration());
    }

    private ClientRegistration auth0ClientRegistration() {
        return ClientRegistration.withRegistrationId("auth0")
                .clientId(clientId)
                .clientSecret(clientSecret)
                .authorizationUri("https://" + auth0Domain + "/authorize")
                .tokenUri("https://" + auth0Domain + "/oauth/token")
                .userInfoUri("https://" + auth0Domain + "/userinfo")
                .userNameAttributeName(IdTokenClaimNames.SUB)
                .redirectUri(redirectUri)
                .authorizationGrantType(AuthorizationGrantType.AUTHORIZATION_CODE)
                .scope("openid", "profile", "email")
                .build();
    }
}

// 自定义授权请求解析器，添加prompt=none参数
class CustomAuth0AuthorizationRequestResolver implements OAuth2AuthorizationRequestResolver {
    private final OAuth2AuthorizationRequestResolver defaultResolver;
    private final String auth0Domain;
    private final String clientId;

    public CustomAuth0AuthorizationRequestResolver(String auth0Domain, String clientId) {
        this.auth0Domain = auth0Domain;
        this.clientId = clientId;
        this.defaultResolver = new DefaultOAuth2AuthorizationRequestResolver(
                clientRegistrationRepository(), "/oauth2/authorization");
    }

    @Override
    public OAuth2AuthorizationRequest resolve(HttpServletRequest request) {
        OAuth2AuthorizationRequest authorizationRequest = defaultResolver.resolve(request);
        return authorizationRequest != null ? customizeAuthorizationRequest(authorizationRequest) : null;
    }

    @Override
    public OAuth2AuthorizationRequest resolve(HttpServletRequest request, String clientRegistrationId) {
        OAuth2AuthorizationRequest authorizationRequest = defaultResolver.resolve(request, clientRegistrationId);
        return authorizationRequest != null ? customizeAuthorizationRequest(authorizationRequest) : null;
    }

    private OAuth2AuthorizationRequest customizeAuthorizationRequest(OAuth2AuthorizationRequest authorizationRequest) {
        Map<String, Object> additionalParameters = new LinkedHashMap<>(authorizationRequest.getAdditionalParameters());
        additionalParameters.put("prompt", "none"); // 添加静默SSO参数
        return OAuth2AuthorizationRequest.from(authorizationRequest)
                .additionalParameters(additionalParameters)
                .build();
    }
}

跨应用静默SSO实现 #

在应用首页加载时，前端发起请求到后端的静默登录端点，后端触发带prompt=none的授权请求：

• 若Auth0返回授权码，后端完成认证并创建会话，用户自动登录；
• 若返回login_required，则显示正常登录按钮。

跨应用单点注销配置 #

1. Auth0控制台配置：
   • 为每个应用设置Allowed Logout URLs，如https://app1.example.com/logout/success；
   • 开启单点注销，设置注销回调URL为https://app1.example.com/logout/callback。
2. Spring Security注销配置：

@Override
protected void configure(HttpSecurity http) throws Exception {
    // ... 其他配置
    http.logout()
            .logoutUrl("/logout")
            .logoutSuccessHandler(new Auth0LogoutSuccessHandler(auth0Domain, clientId, "https://app1.example.com/logout/success"));
}

// 自定义注销成功处理器
class Auth0LogoutSuccessHandler implements LogoutSuccessHandler {
    private final String auth0Domain;
    private final String clientId;
    private final String returnToUrl;

    public Auth0LogoutSuccessHandler(String auth0Domain, String clientId, String returnToUrl) {
        this.auth0Domain = auth0Domain;
        this.clientId = clientId;
        this.returnToUrl = returnToUrl;
    }

    @Override
    public void onLogoutSuccess(HttpServletRequest request, HttpServletResponse response, Authentication authentication) throws IOException, ServletException {
        String logoutUrl = String.format("https://%s/v2/logout?client_id=%s&returnTo=%s",
                auth0Domain, clientId, URLEncoder.encode(returnToUrl, StandardCharsets.UTF_8.name()));
        response.sendRedirect(logoutUrl);
    }
}

3. 注销回调端点实现：

@Controller
@RequestMapping("/logout/callback")
public class LogoutCallbackController {
    @Autowired
    private SessionRegistry sessionRegistry;
    @Autowired
    private RedisTemplate<String, String> redisTemplate; // 用Redis维护sub与JSESSIONID的映射

    @GetMapping
    public String handleLogoutCallback(@RequestParam("sub") String userId) {
        // 根据userId查找所有关联的JSESSIONID
        Set<String> sessionIds = redisTemplate.opsForSet().members("auth0:sub:" + userId);
        if (sessionIds != null) {
            for (String sessionId : sessionIds) {
                SessionInformation sessionInfo = sessionRegistry.getSessionInformation(sessionId);
                if (sessionInfo != null) {
                    sessionInfo.expireNow(); // 失效会话
                }
                redisTemplate.delete("auth0:session:" + sessionId);
            }
            redisTemplate.delete("auth0:sub:" + userId);
        }
        return "redirect:/logout/success";
    }
}

注：需要在用户登录成功后，将sub与JSESSIONID的映射存储到Redis中。

Spring MVC SSR的Auth0最佳配置 #

• 采用授权码流：避免使用隐式流，授权码流更安全，适合服务器端应用。
• 服务器端存储令牌：ID Token和Access Token仅存储在服务器端会话中，不暴露给客户端。
• 自定义用户服务：通过OAuth2UserService加载租户元数据到SecurityContext，支持多租户路由。
• 分布式会话存储：用Redis等存储会话，方便跨应用SLO时查找和失效会话。
• Token过期与刷新：配置会话超时时间与Auth0 Token过期时间一致，或实现服务器端的Token刷新逻辑。

内容的提问来源于stack exchange，提问作者Abhishek Singh