Otentikasi tenang melalui musim semi

Masalah:
Kami memiliki RESTful API Spring MVC berbasis yang berisi informasi sensitif. API harus diamankan, namun mengirimkan kredensial pengguna (kombo / pengguna) dengan setiap permintaan tidak diinginkan. Per pedoman REST (dan persyaratan bisnis internal), server harus tetap tanpa kewarganegaraan. API akan dikonsumsi oleh server lain dengan pendekatan gaya mashup.

Persyaratan:

• Klien membuat permintaan ke .../authenticate(URL yang tidak dilindungi) dengan kredensial; server mengembalikan token aman yang berisi informasi yang cukup bagi server untuk memvalidasi permintaan di masa mendatang dan tetap tanpa kewarganegaraan. Ini kemungkinan terdiri dari informasi yang sama dengan Remember-Me Token Spring Security .

• Klien membuat permintaan berikutnya ke berbagai URL (terlindungi), menambahkan token yang diperoleh sebelumnya sebagai parameter kueri (atau, yang kurang diinginkan, header permintaan HTTP).

• Klien tidak dapat diharapkan untuk menyimpan cookie.

• Karena kita sudah menggunakan Spring, solusinya harus menggunakan Spring Security.

Kami telah membenturkan kepala kami ke dinding mencoba membuat ini bekerja, jadi semoga seseorang di luar sana telah menyelesaikan masalah ini.

Dengan skenario di atas, bagaimana Anda bisa menyelesaikan kebutuhan khusus ini?

Kami berhasil agar ini berfungsi persis seperti yang dijelaskan dalam OP, dan mudah-mudahan orang lain dapat memanfaatkan solusinya. Inilah yang kami lakukan:

Atur konteks keamanan seperti ini:

<security:http realm="Protected API" use-expressions="true" auto-config="false" create-session="stateless" entry-point-ref="CustomAuthenticationEntryPoint">
    <security:custom-filter ref="authenticationTokenProcessingFilter" position="FORM_LOGIN_FILTER" />
    <security:intercept-url pattern="/authenticate" access="permitAll"/>
    <security:intercept-url pattern="/**" access="isAuthenticated()" />
</security:http>

<bean id="CustomAuthenticationEntryPoint"
    class="com.demo.api.support.spring.CustomAuthenticationEntryPoint" />

<bean id="authenticationTokenProcessingFilter"
    class="com.demo.api.support.spring.AuthenticationTokenProcessingFilter" >
    <constructor-arg ref="authenticationManager" />
</bean>

Seperti yang Anda lihat, kami telah membuat sebuah kebiasaan AuthenticationEntryPoint, yang pada dasarnya hanya mengembalikan a 401 Unauthorizedjika permintaan tidak diautentikasi dalam rantai filter oleh kami AuthenticationTokenProcessingFilter.

CustomAuthenticationEntryPoint :

public class CustomAuthenticationEntryPoint implements AuthenticationEntryPoint {
    @Override
    public void commence(HttpServletRequest request, HttpServletResponse response,
            AuthenticationException authException) throws IOException, ServletException {
        response.sendError( HttpServletResponse.SC_UNAUTHORIZED, "Unauthorized: Authentication token was either missing or invalid." );
    }
}

AuthenticationTokenProcessingFilter :

public class AuthenticationTokenProcessingFilter extends GenericFilterBean {

    @Autowired UserService userService;
    @Autowired TokenUtils tokenUtils;
    AuthenticationManager authManager;

    public AuthenticationTokenProcessingFilter(AuthenticationManager authManager) {
        this.authManager = authManager;
    }

    @Override
    public void doFilter(ServletRequest request, ServletResponse response,
            FilterChain chain) throws IOException, ServletException {
        @SuppressWarnings("unchecked")
        Map<String, String[]> parms = request.getParameterMap();

        if(parms.containsKey("token")) {
            String token = parms.get("token")[0]; // grab the first "token" parameter

            // validate the token
            if (tokenUtils.validate(token)) {
                // determine the user based on the (already validated) token
                UserDetails userDetails = tokenUtils.getUserFromToken(token);
                // build an Authentication object with the user's info
                UsernamePasswordAuthenticationToken authentication = 
                        new UsernamePasswordAuthenticationToken(userDetails.getUsername(), userDetails.getPassword());
                authentication.setDetails(new WebAuthenticationDetailsSource().buildDetails((HttpServletRequest) request));
                // set the authentication into the SecurityContext
                SecurityContextHolder.getContext().setAuthentication(authManager.authenticate(authentication));         
            }
        }
        // continue thru the filter chain
        chain.doFilter(request, response);
    }
}

Jelas, TokenUtilsberisi beberapa kode rahasia (dan sangat khusus kasus) dan tidak dapat dibagikan dengan mudah. Inilah antarmuka-nya:

public interface TokenUtils {
    String getToken(UserDetails userDetails);
    String getToken(UserDetails userDetails, Long expiration);
    boolean validate(String token);
    UserDetails getUserFromToken(String token);
}

Itu seharusnya membuat Anda memulai dengan baik. Selamat coding. :)

Anda mungkin mempertimbangkan Otentikasi Akses Intisari . Intinya protokol adalah sebagai berikut:

1. Permintaan dibuat dari klien
2. Server merespons dengan string nonce unik
3. Klien menyediakan nama pengguna dan kata sandi (dan beberapa nilai lainnya) md5 hash dengan thecece; hash ini dikenal sebagai HA1
4. Server kemudian dapat memverifikasi identitas klien dan menyajikan materi yang diminta
5. Komunikasi dengan nonce dapat berlanjut sampai server memasok nonce baru (penghitung digunakan untuk menghilangkan serangan replay)

Semua komunikasi ini dilakukan melalui tajuk, yang, seperti ditunjukkan jmort253, umumnya lebih aman daripada mengomunikasikan materi sensitif dalam parameter url.

Otentikasi Akses Digest didukung oleh Spring Security . Perhatikan bahwa, meskipun dokumen mengatakan bahwa Anda harus memiliki akses ke kata sandi teks biasa klien Anda, Anda dapat berhasil mengotentikasi jika Anda memiliki hash HA1 untuk klien Anda.

Mengenai token yang membawa informasi, JSON Web Tokens ( http://jwt.io ) adalah teknologi yang brilian. Konsep utamanya adalah memasukkan elemen informasi (klaim) ke dalam token, dan kemudian menandatangani seluruh token sehingga akhir yang valid dapat memverifikasi bahwa klaim tersebut memang dapat dipercaya.

Saya menggunakan implementasi Java ini: https://bitbucket.org/b_c/jose4j/wiki/Home

Ada juga modul Spring (spring-security-jwt), tapi saya belum melihat apa yang didukungnya.

Mengapa Anda tidak mulai menggunakan OAuth dengan JSON WebTokens

http://projects.spring.io/spring-security-oauth/

OAuth2 adalah protokol / kerangka kerja otorisasi standar. Sesuai Spesifikasi Resmi OAuth2 :

Anda dapat menemukan info lebih lanjut di sini