如何在没有会话的情况下使用 Spring Security？

Question

我正在使用 Spring Security 构建一个 Web 应用程序，该应用程序将运行在 Amazon EC2 上并使用 Amazon 的弹性负载均衡器。不幸的是，ELB 不支持粘性会话，因此我需要确保我的应用程序在没有会话的情况下正常工作。

到目前为止，我已经设置 RememberMeServices 通过 cookie 分配令牌，这工作正常，但我希望 cookie 在浏览器会话中过期（例如，当浏览器关闭时）。

我必须想象我不是第一个想要在没有会话的情况下使用 Spring Security 的人......有什么建议吗？

Answer 1

在 Spring Security 3 中 Java配置，可以使用HttpSecurity.sessionManagement()：

@Override
protected void configure(final HttpSecurity http) throws Exception {
    http
        .sessionManagement()
            .sessionCreationPolicy(SessionCreationPolicy.STATELESS);
}

Answer 2

今天，我们花了 4-5 个小时来解决同一问题（将自定义 SecurityContextRepository 注入 SecurityContextPersistenceFilter）。最后，我们想通了。
首先，在 Spring Security ref 的 8.3 节中。 doc，有一个 SecurityContextPersistenceFilter bean 定义

<bean id="securityContextPersistenceFilter" class="org.springframework.security.web.context.SecurityContextPersistenceFilter">
    <property name='securityContextRepository'>
        <bean class='org.springframework.security.web.context.HttpSessionSecurityContextRepository'>
            <property name='allowSessionCreation' value='false' />
        </bean>
    </property>
</bean>

在这个定义之后，有这样的解释：
“或者，您可以提供 SecurityContextRepository 接口的 null 实现，这将阻止存储安全上下文，即使在请求期间已经创建了会话。”

我们需要将自定义的 SecurityContextRepository 注入 SecurityContextPersistenceFilter 中。因此，我们只需使用自定义实现更改上面的 bean 定义，并将其放入安全上下文中。

当我们运行应用程序时，我们跟踪日志并发现 SecurityContextPersistenceFilter 没有使用我们的自定义实现，而是使用 HttpSessionSecurityContextRepository。

在我们尝试了一些其他事情之后，我们发现我们必须为我们的自定义 SecurityContextRepository impl 提供“http”命名空间的“security-context-repository-ref”属性。如果您使用“http”命名空间并希望注入自己的 SecurityContextRepository impl，请尝试“security-context-repository-ref”属性。

当使用“http”命名空间时，单独的 SecurityContextPersistenceFilter 定义将被忽略。正如我在上面复制的，参考文档。没有说明这一点。

如果我误解了这些事情，请纠正我。

Answer 3

在 Spring Securitiy 3.0 中似乎更加容易。如果您使用名称空间配置，则可以简单地执行以下操作：

<http create-session="never">
  <!-- config -->
</http>

或者您可以将 SecurityContextRepository 配置为 null，这样就不会保存任何内容 以及。

Answer 4

看一下 SecurityContextPersistenceFilter 类。它定义了如何填充SecurityContextHolder。默认情况下，它使用 HttpSessionSecurityContextRepository 来存储 http 会话中的安全上下文。

我已经使用自定义的 SecurityContextRepository 非常轻松地实现了此机制。

请参阅下面的 securityContext.xml：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xmlns:sec="http://www.springframework.org/schema/security"
       xmlns:jee="http://www.springframework.org/schema/jee"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
       http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.0.xsd
       http://www.springframework.org/schema/security http://www.springframework.org/schema/security/spring-security.xsd
       http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee-3.0.xsd">

    <context:annotation-config/>

    <sec:global-method-security secured-annotations="enabled" pre-post-annotations="enabled"/>

    <bean id="securityContextRepository" class="com.project.server.security.TokenSecurityContextRepository"/>

    <bean id="securityContextFilter" class="com.project.server.security.TokenSecurityContextPersistenceFilter">
        <property name="repository" ref="securityContextRepository"/>
    </bean>

    <bean id="logoutFilter" class="org.springframework.security.web.authentication.logout.LogoutFilter">
        <constructor-arg value="/login.jsp"/>
        <constructor-arg>
            <list>
                <bean class="org.springframework.security.web.authentication.logout.SecurityContextLogoutHandler"/>
            </list>
        </constructor-arg>
    </bean>

    <bean id="formLoginFilter"
          class="org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter">
        <property name="authenticationManager" ref="authenticationManager"/>
        <property name="authenticationSuccessHandler">
            <bean class="com.project.server.security.TokenAuthenticationSuccessHandler">
                <property name="defaultTargetUrl" value="/index.html"/>
                <property name="passwordExpiredUrl" value="/changePassword.jsp"/>
                <property name="alwaysUseDefaultTargetUrl" value="true"/>
            </bean>
        </property>
        <property name="authenticationFailureHandler">
            <bean class="com.project.server.modules.security.CustomUrlAuthenticationFailureHandler">
                <property name="defaultFailureUrl" value="/login.jsp?failure=1"/>
            </bean>
        </property>
        <property name="filterProcessesUrl" value="/j_spring_security_check"/>
        <property name="allowSessionCreation" value="false"/>
    </bean>

    <bean id="servletApiFilter"
          class="org.springframework.security.web.servletapi.SecurityContextHolderAwareRequestFilter"/>

    <bean id="anonFilter" class="org.springframework.security.web.authentication.AnonymousAuthenticationFilter">
        <property name="key" value="ClientApplication"/>
        <property name="userAttribute" value="anonymousUser,ROLE_ANONYMOUS"/>
    </bean>


    <bean id="exceptionTranslator" class="org.springframework.security.web.access.ExceptionTranslationFilter">
        <property name="authenticationEntryPoint">
            <bean class="org.springframework.security.web.authentication.LoginUrlAuthenticationEntryPoint">
                <property name="loginFormUrl" value="/login.jsp"/>
            </bean>
        </property>
        <property name="accessDeniedHandler">
            <bean class="org.springframework.security.web.access.AccessDeniedHandlerImpl">
                <property name="errorPage" value="/login.jsp?failure=2"/>
            </bean>
        </property>
        <property name="requestCache">
            <bean id="nullRequestCache" class="org.springframework.security.web.savedrequest.NullRequestCache"/>
        </property>
    </bean>

    <alias name="filterChainProxy" alias="springSecurityFilterChain"/>

    <bean id="filterChainProxy" class="org.springframework.security.web.FilterChainProxy">
        <sec:filter-chain-map path-type="ant">
            <sec:filter-chain pattern="/**"
                              filters="securityContextFilter, logoutFilter, formLoginFilter,
                                        servletApiFilter, anonFilter, exceptionTranslator, filterSecurityInterceptor"/>
        </sec:filter-chain-map>
    </bean>

    <bean id="filterSecurityInterceptor"
          class="org.springframework.security.web.access.intercept.FilterSecurityInterceptor">
        <property name="securityMetadataSource">
            <sec:filter-security-metadata-source use-expressions="true">
                <sec:intercept-url pattern="/staticresources/**" access="permitAll"/>
                <sec:intercept-url pattern="/index.html*" access="hasRole('USER_ROLE')"/>
                <sec:intercept-url pattern="/rpc/*" access="hasRole('USER_ROLE')"/>
                <sec:intercept-url pattern="/**" access="permitAll"/>
            </sec:filter-security-metadata-source>
        </property>
        <property name="authenticationManager" ref="authenticationManager"/>
        <property name="accessDecisionManager" ref="accessDecisionManager"/>
    </bean>

    <bean id="accessDecisionManager" class="org.springframework.security.access.vote.AffirmativeBased">
        <property name="decisionVoters">
            <list>
                <bean class="org.springframework.security.access.vote.RoleVoter"/>
                <bean class="org.springframework.security.web.access.expression.WebExpressionVoter"/>
            </list>
        </property>
    </bean>

    <bean id="authenticationManager" class="org.springframework.security.authentication.ProviderManager">
        <property name="providers">
            <list>
                <bean name="authenticationProvider"
                      class="com.project.server.modules.security.oracle.StoredProcedureBasedAuthenticationProviderImpl">
                    <property name="dataSource" ref="serverDataSource"/>
                    <property name="userDetailsService" ref="userDetailsService"/>
                    <property name="auditLogin" value="true"/>
                    <property name="postAuthenticationChecks" ref="customPostAuthenticationChecks"/>
                </bean>
            </list>
        </property>
    </bean>

    <bean id="customPostAuthenticationChecks" class="com.project.server.modules.security.CustomPostAuthenticationChecks"/>

    <bean name="userDetailsService" class="com.project.server.modules.security.oracle.UserDetailsServiceImpl">
        <property name="dataSource" ref="serverDataSource"/>
    </bean>

</beans>

Answer 5

实际上 create-session="never" 并不意味着完全无状态。 Spring Security 问题管理中存在一个问题。

Answer 6

编辑：从 Spring Security 3.1 开始，有一个 STATELESS 选项可以用来代替所有这些。请参阅其他答案。原始答案保留在下面供后代使用。

在与这个答案中发布的众多解决方案进行斗争之后，为了尝试在使用 命名空间配置时让某些东西正常工作，我终于找到了一种真正适合我的用例的方法。我实际上并不要求 Spring Security 不启动会话（因为我在应用程序的其他部分使用会话），只是它根本不“记住”会话中的身份验证（应该重新检查）每个请求）。

首先，我无法弄清楚如何执行上述“空实现”技术。目前尚不清楚您是否应该将 securityContextRepository 设置为 null 还是无操作实现。前者不起作用，因为在 SecurityContextPersistenceFilter.doFilter() 中抛出了 NullPointerException。至于无操作实现，我尝试以我能想象到的最简单的方式实现：

public class NullSpringSecurityContextRepository implements SecurityContextRepository {

    @Override
    public SecurityContext loadContext(final HttpRequestResponseHolder requestResponseHolder_) {
        return SecurityContextHolder.createEmptyContext();
    }

    @Override
    public void saveContext(final SecurityContext context_, final HttpServletRequest request_,
            final HttpServletResponse response_) {
    }

    @Override
    public boolean containsContext(final HttpServletRequest request_) {
        return false;
    }

}

这在我的应用程序中不起作用，因为一些奇怪的 ClassCastException 与 response_< /代码> 类型。

即使假设我确实找到了一个可行的实现（通过简单地不在会话中存储上下文），仍然存在如何将其注入到由 配置构建的过滤器中的问题。您不能简单地替换 SECURITY_CONTEXT_FILTER 位置的过滤器，按照 文档。我发现连接到在幕后创建的 SecurityContextPersistenceFilter 的唯一方法是编写一个丑陋的 ApplicationContextAware bean：

public class SpringSecuritySessionDisabler implements ApplicationContextAware {

    private final Logger logger = LoggerFactory.getLogger(SpringSecuritySessionDisabler.class);

    private ApplicationContext applicationContext;

    @Override
    public void setApplicationContext(final ApplicationContext applicationContext_) throws BeansException {
        applicationContext = applicationContext_;
    }

    public void disableSpringSecuritySessions() {
        final Map<String, FilterChainProxy> filterChainProxies = applicationContext
                .getBeansOfType(FilterChainProxy.class);
        for (final Entry<String, FilterChainProxy> filterChainProxyBeanEntry : filterChainProxies.entrySet()) {
            for (final Entry<String, List<Filter>> filterChainMapEntry : filterChainProxyBeanEntry.getValue()
                    .getFilterChainMap().entrySet()) {
                final List<Filter> filterList = filterChainMapEntry.getValue();
                if (filterList.size() > 0) {
                    for (final Filter filter : filterList) {
                        if (filter instanceof SecurityContextPersistenceFilter) {
                            logger.info(
                                    "Found SecurityContextPersistenceFilter, mapped to URL '{}' in the FilterChainProxy bean named '{}', setting its securityContextRepository to the null implementation to disable caching of authentication",
                                    filterChainMapEntry.getKey(), filterChainProxyBeanEntry.getKey());
                            ((SecurityContextPersistenceFilter) filter).setSecurityContextRepository(
                             new NullSpringSecurityContextRepository());
                        }
                    }
                }

            }
        }
    }
}

无论如何，对于实际有效的解决方案，尽管非常黑客式的。只需使用 Filter 来删除 HttpSessionSecurityContextRepository 在执行其操作时查找的会话条目：

public class SpringSecuritySessionDeletingFilter extends GenericFilterBean implements Filter {

    @Override
    public void doFilter(final ServletRequest request_, final ServletResponse response_, final FilterChain chain_)
            throws IOException, ServletException {
        final HttpServletRequest servletRequest = (HttpServletRequest) request_;
        final HttpSession session = servletRequest.getSession();
        if (session.getAttribute(HttpSessionSecurityContextRepository.SPRING_SECURITY_CONTEXT_KEY) != null) {
            session.removeAttribute(HttpSessionSecurityContextRepository.SPRING_SECURITY_CONTEXT_KEY);
        }

        chain_.doFilter(request_, response_);
    }
}

然后在配置中：

<bean id="springSecuritySessionDeletingFilter"
    class="SpringSecuritySessionDeletingFilter" />

<sec:http auto-config="false" create-session="never"
    entry-point-ref="authEntryPoint">
    <sec:intercept-url pattern="/**"
        access="IS_AUTHENTICATED_REMEMBERED" />
    <sec:intercept-url pattern="/static/**" filters="none" />
    <sec:custom-filter ref="myLoginFilterChain"
        position="FORM_LOGIN_FILTER" />

    <sec:custom-filter ref="springSecuritySessionDeletingFilter"
        before="SECURITY_CONTEXT_FILTER" />
</sec:http>

Answer 7

只是一个快速说明：它是“create-session”而不是“create-sessions”

create-session

控制创建 HTTP 会话的急切程度。

如果未设置，则默认为“ifRequired”。其他选项是“总是”和“从不”。

此属性的设置会影响 HttpSessionContextIntegrationFilter 的allowSessionCreation 和forceEagerSessionCreation 属性。除非该属性设置为“never”，否则allowSessionCreation 将始终为true。除非将其设置为“始终”，否则forceEagerSessionCreation 为“假”。

因此，默认配置允许会话创建，但不强制创建。例外情况是，如果启用并发会话控制，则​​无论此处的设置是什么，forceEagerSessionCreation 将设置为 true。使用“never”会在 HttpSessionContextIntegrationFilter 初始化期间导致异常。

有关会话使用的具体细节，HttpSessionSecurityContextRepository javadoc 中有一些很好的文档。

Answer 8

现在 ELB 支持粘性会话，我想从 2016 年开始。
而且还可以将会话存储在 Redis 中。