Bagaimana saya bisa menggunakan Keamanan Musim Semi tanpa sesi?

Saya membuat aplikasi web dengan Spring Security yang akan tersedia di Amazon EC2 dan menggunakan Elastic Load Balancers Amazon. Sayangnya, ELB tidak mendukung sesi lengket, jadi saya perlu memastikan aplikasi saya berfungsi dengan baik tanpa sesi.

Sejauh ini, saya telah menyiapkan RememberMeServices untuk menetapkan token melalui cookie, dan ini berfungsi dengan baik, tetapi saya ingin cookie itu kedaluwarsa dengan sesi browser (mis. Saat browser ditutup).

Saya harus membayangkan saya bukan orang pertama yang ingin menggunakan Keamanan Musim Semi tanpa sesi ... ada saran?

Di Spring Security 3 dengan Java Config , Anda dapat menggunakan HttpSecurity.sessionManagement () :

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

Tampaknya menjadi lebih mudah di Spring Securitiy 3.0. Jika Anda menggunakan konfigurasi namespace, Anda cukup melakukan hal berikut:

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

Atau Anda dapat mengonfigurasi SecurityContextRepository sebagai null, dan tidak ada yang bisa disimpan dengan cara itu juga .

Kami menangani masalah yang sama (memasukkan SecurityContextRepository kustom ke SecurityContextPersistenceFilter) selama 4-5 jam hari ini. Akhirnya, kami menemukan jawabannya. Pertama-tama, di bagian 8.3 dari Keamanan Musim Semi ref. doc, ada definisi kacang SecurityContextPersistenceFilter

<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>

Dan setelah definisi ini, ada penjelasan berikut: "Alternatifnya, Anda dapat memberikan implementasi null dari antarmuka SecurityContextRepository, yang akan mencegah konteks keamanan disimpan, bahkan jika sesi telah dibuat selama permintaan."

Kami perlu memasukkan SecurityContextRepository kustom kami ke dalam SecurityContextPersistenceFilter. Jadi kami hanya mengubah definisi kacang di atas dengan impl kustom kami dan memasukkannya ke dalam konteks keamanan.

Saat kami menjalankan aplikasi, kami menelusuri log dan melihat bahwa SecurityContextPersistenceFilter tidak menggunakan impl kustom kami, melainkan menggunakan HttpSessionSecurityContextRepository.

Setelah beberapa hal lain yang kami coba, kami menemukan bahwa kami harus memberikan custom SecurityContextRepository impl kami dengan atribut "security-context-repository-ref" dari namespace "http". Jika Anda menggunakan namespace "http" dan ingin memasukkan impl SecurityContextRepository Anda sendiri, coba atribut "security-context-repository-ref".

Ketika namespace "http" digunakan, definisi SecurityContextPersistenceFilter yang terpisah diabaikan. Seperti yang saya salin di atas, dokumen referensi. tidak menyatakan itu.

Harap perbaiki saya jika saya salah paham.

Lihat SecurityContextPersistenceFilterkelas. Ini mendefinisikan bagaimana SecurityContextHolderpenduduknya. Secara default digunakan HttpSessionSecurityContextRepositoryuntuk menyimpan konteks keamanan di sesi http.

Mekanisme ini sudah saya implementasikan dengan cukup mudah, dengan custom SecurityContextRepository.

Lihat di securityContext.xmlbawah ini:

<?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>

Sebenarnya create-session="never"tidak berarti sepenuhnya tanpa kewarganegaraan. Ada masalah untuk itu dalam manajemen masalah Keamanan Musim Semi.

Setelah berjuang dengan banyak solusi yang diposting dalam jawaban ini, untuk mencoba mendapatkan sesuatu yang berfungsi saat menggunakan <http>konfigurasi namespace, saya akhirnya menemukan pendekatan yang benar-benar berfungsi untuk kasus penggunaan saya. Saya sebenarnya tidak mengharuskan Spring Security tidak memulai sesi (karena saya menggunakan sesi di bagian lain aplikasi), hanya saja Spring Security tidak "mengingat" otentikasi dalam sesi sama sekali (harus diperiksa ulang setiap permintaan).

Untuk memulainya, saya tidak dapat menemukan cara untuk melakukan teknik "implementasi nol" yang dijelaskan di atas. Tidak jelas apakah Anda harus menyetel securityContextRepository ke nullatau ke implementasi tanpa operasi. Yang pertama tidak berfungsi karena a NullPointerExceptionterlempar ke dalam SecurityContextPersistenceFilter.doFilter(). Sedangkan untuk implementasi tanpa operasi, saya mencoba menerapkan dengan cara yang paling sederhana yang dapat saya bayangkan:

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

}

Ini tidak berfungsi di aplikasi saya, karena ada yang aneh ClassCastExceptiondengan response_jenisnya.

Bahkan dengan asumsi saya berhasil menemukan implementasi yang berfungsi (dengan tidak menyimpan konteks dalam sesi), masih ada masalah tentang bagaimana menyuntikkannya ke dalam filter yang dibangun oleh <http>konfigurasi. Anda tidak bisa begitu saja mengganti filter pada SECURITY_CONTEXT_FILTERposisi tersebut, sesuai dengan dokumen . Satu-satunya cara saya menemukan untuk mengaitkan SecurityContextPersistenceFilteryang dibuat di bawah sampul adalah dengan menulis ApplicationContextAwarekacang jelek :

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

            }
        }
    }
}

Bagaimanapun, ke solusi yang benar-benar berfungsi, meskipun sangat hackish. Cukup gunakan Filteryang menghapus entri sesi yang HttpSessionSecurityContextRepositorydicari saat melakukan tugasnya:

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

Kemudian di konfigurasi:

<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>

Hanya catatan singkat: ini "sesi-buat" daripada "sesi-buat"

buat-sesi

Mengontrol keinginan pembuatan sesi HTTP.

Jika tidak disetel, defaultnya adalah "ifRequired". Pilihan lainnya adalah "selalu" dan "tidak pernah".

Setelan atribut ini memengaruhi properti allowSessionCreation dan forceEagerSessionCreation dari HttpSessionContextIntegrationFilter. allowSessionCreation akan selalu benar kecuali atribut ini disetel ke "tidak pernah". forceEagerSessionCreation adalah "false" kecuali jika disetel ke "selalu".

Jadi konfigurasi default memungkinkan pembuatan sesi tetapi tidak memaksanya. Pengecualiannya adalah jika kontrol sesi serentak diaktifkan, saat forceEagerSessionCreation akan disetel ke true, apa pun setelannya di sini. Menggunakan "tidak pernah" akan menyebabkan pengecualian selama inisialisasi HttpSessionContextIntegrationFilter.

Untuk detail spesifik dari penggunaan sesi, ada beberapa dokumentasi bagus di javadoc HttpSessionSecurityContextRepository.