使用 JWT 和基本身份验证保护 REST 应用程序是否有意义？

Question

我有一个 Spring REST 应用程序，最初使用基本身份验证进行保护。

然后我添加了一个登录控制器，它创建了一个 JWT JSON Web Token，用于后续请求。

我可以将以下代码移出登录控制器并进入安全过滤器吗？然后我就不再需要登录控制器了。

tokenAuthenticationService.addTokenToResponseHeader(responseHeaders, credentialsResource.getEmail());

或者我可以删除基本身份验证吗？

将基本身份验证与 JWT 混合使用是一个好的设计吗？

虽然一切正常，但我对如何最好地设计这种安全性有点不知所措。

Answer 1

假设所有通信都使用 100% TLS - 无论是在登录期间还是登录后的所有时间 - 通过基本身份验证使用用户名/密码进行身份验证并接收 JWT 作为交换是一个有效的用例。这几乎正是 OAuth 2 的流程之一（“密码授予”）的工作原理。

这个想法是最终用户通过一个端点进行身份验证，例如/login/token 使用您想要的任何机制，并且响应应该包含要在所有后续请求中发回的 JWT。 JWT 应该是具有适当 JWT 过期 (exp) 字段的 JWS（即加密签名的 JWT）：这可确保客户端无法操纵 JWT 或使其寿命超过应有的时间。

您也不需要X-Auth-Token 标头：HTTP 身份验证Bearer 方案是为这个确切的用例创建的：基本上任何位于Bearer 方案名称后面的信息都是“承载”信息，应该得到验证。您只需设置 Authorization 标头：

Authorization: Bearer <JWT value here>

但是，话虽如此，如果您的 REST 客户端是“不受信任的”（例如启用 JavaScript 的浏览器），我什至不会这样做：HTTP 响应中可通过 JavaScript 访问的任何值 - 基本上是任何标头值或响应体值 - 可以通过 MITM XSS 攻击被嗅探和拦截。

最好将 JWT 值存储在仅安全、仅 http 的 cookie 中（cookie 配置：setSecure(true)、setHttpOnly(true)）。这保证了浏览器将：

1. 仅通过 TLS 连接传输 cookie，并且，
2. 永远不要让 cookie 值可用于 JavaScript 代码。

这种方法几乎是您为实现最佳实践安全所需做的一切。最后一件事是确保您对每个 HTTP 请求都有 CSRF 保护，以确保向您的站点发起请求的外部域无法运行。

最简单的方法是使用随机值设置一个仅安全（但不是仅 http）的 cookie，例如一个 UUID。

然后，在对服务器的每个请求中，确保您自己的 JavaScript 代码读取 cookie 值并将其设置在自定义标头中，例如X-CSRF-Token 并在服务器中的每个请求上验证该值。除非外部客户端通过 HTTP 选项请求获得授权，否则外部域客户端无法为对您的域的请求设置自定义标头，因此任何 CSRF 攻击尝试（例如在 IFrame 中，等等）都将失败。

据我们所知，这是当今网络上不受信任的 JavaScript 客户端可用的同类最佳安全性。如果你好奇的话，Stormpath 也在these techniques 上写了一篇文章。 HTH！

Answer 2

这里有一些代码来支持如何在 Spring 中执行此操作的公认答案....只需扩展 UsernamePasswordAuthenticationFilter 并将其添加到 Spring Security...这适用于 HTTP Basic Authentication + Spring Security

public class JWTAuthenticationFilter extends UsernamePasswordAuthenticationFilter {

    private AuthenticationManager authenticationManager;

    public JWTAuthenticationFilter(AuthenticationManager authenticationManager) {

        this.authenticationManager = authenticationManager;

    }

    @Override

    public Authentication attemptAuthentication(HttpServletRequest req,

                                                HttpServletResponse res) throws AuthenticationException {

        try {

            ApplicationUser creds = new ObjectMapper()

                    .readValue(req.getInputStream(), ApplicationUser.class);

            return authenticationManager.authenticate(

                    new UsernamePasswordAuthenticationToken(

                            creds.getUsername(),

                            creds.getPassword(),

                            new ArrayList<>())

            );

        } catch (IOException e) {

            throw new RuntimeException(e);

        }

    }

    @Override

    protected void successfulAuthentication(HttpServletRequest req,

                                            HttpServletResponse res,

                                            FilterChain chain,

                                            Authentication auth) throws IOException, ServletException {

        String token = Jwts.builder()

                .setSubject(((User) auth.getPrincipal()).getUsername())

                .setExpiration(new Date(System.currentTimeMillis() + EXPIRATION_TIME))

                .signWith(SignatureAlgorithm.HS512, SECRET)

                .compact();

        res.addHeader(HEADER_STRING, TOKEN_PREFIX + token);

    }

}

使用 JWT 库：

<!-- https://mvnrepository.com/artifact/io.jsonwebtoken/jjwt -->
<dependency>
    <groupId>io.jsonwebtoken</groupId>
    <artifactId>jjwt</artifactId>
    <version>0.9.0</version>
</dependency>

spring boot 配置类

package com.vanitysoft.payit.security.web.impl;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
import org.springframework.http.HttpMethod;
import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder;
import org.springframework.security.config.annotation.method.configuration.EnableGlobalMethodSecurity;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;

    import org.springframework.security.config.http.SessionCreationPolicy;
    import org.springframework.security.core.userdetails.UserDetailsService;
    import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;

    import com.vanitysoft.payit.util.SecurityConstants;

    @Configuration
    @EnableWebSecurity
    @EnableGlobalMethodSecurity(prePostEnabled = true)
    public class SecurityConfig extends WebSecurityConfigurerAdapter {
         @Autowired
           private UserDetailsService userDetailsService;

            @Autowired
            private  BCryptPasswordEncoder bCryptPasswordEncoder;

         @Override
           protected void configure(AuthenticationManagerBuilder auth) throws Exception {
              auth.userDetailsService(userDetailsService)
                      .passwordEncoder(bCryptPasswordEncoder);
           }

         @Override
            protected void configure(HttpSecurity http) throws Exception {
             http.cors().and().csrf().disable()
                    .authorizeRequests()                             
                        .antMatchers(HttpMethod.POST, SecurityConstants.SIGN_UP_URL).permitAll()
                        .antMatchers("/user/**").authenticated()
                        .and()
                        .httpBasic()
                        .and()
                        .addFilter(new JWTAuthenticationFilter(authenticationManager()))
                        .addFilter(new JWTAuthorizationFilter(authenticationManager()))
                        .sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS)
                        .and()
                        .logout()
                        .permitAll();

            }
    }