使用Zuul实现安全和认证（二）

原创

堕落飞鸟

发布于 2023-04-10 07:09:26

3480

发布于 2023-04-10 07:09:26

文章被收录于专栏：飞鸟的专栏

使用JWT对请求进行认证和授权

JSON Web Token（JWT）是一种安全的跨域认证机制，用于在网络应用之间传递声明。JWT由三部分组成：头部、负载和签名。头部指定签名算法，负载包含声明信息，签名用于验证令牌的完整性。

在Zuul中，可以使用JWT对请求进行认证和授权。下面是一个示例配置：

@Configuration
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.csrf().disable()
                .authorizeRequests()
                .antMatchers("/auth/**").permitAll()
                .anyRequest().authenticated()
                .and()
                .addFilterBefore(new JwtAuthenticationFilter(), UsernamePasswordAuthenticationFilter.class);
    }
}

在上面的配置中，我们使用@EnableWebSecurity注解启用Spring Security，使用configure方法来配置请求的授权规则，使得除了/auth端点外的所有请求都需要经过认证。还添加了一个JWT认证过滤器，在UsernamePasswordAuthenticationFilter之前执行。

下面是一个示例的JWT认证过滤器实现：

public class JwtAuthenticationFilter extends OncePerRequestFilter {

    private final JwtTokenProvider jwtTokenProvider;

    public JwtAuthenticationFilter(JwtTokenProvider jwtTokenProvider) {
        this.jwtTokenProvider = jwtTokenProvider;
    }

    @Override
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain)
            throws ServletException, IOException {
        String token = jwtTokenProvider.resolveToken(request);
        if (token != null && jwtTokenProvider.validateToken(token)) {
            Authentication auth = jwtTokenProvider.getAuthentication(token);
            SecurityContextHolder.getContext().setAuthentication(auth);
        }
        filterChain.doFilter(request, response);
    }
}

在上面的实现中，我们从请求中获取JWT令牌，验证令牌是否有效，并将验证后的身份验证对象添加到Spring Security的安全上下文中。

接下来，我们需要实现一个JWT令牌提供者。下面是一个示例实现：

@Component
public class JwtTokenProvider {

    private static final String SECRET_KEY = "secret-key";
    private static final long VALIDITY_IN_MILLISECONDS = 3600000;

    private final UserService userService;

    public JwtTokenProvider(UserService userService) {
        this.userService = userService;
    }

    public String createToken(String username) {
        Claims claims = Jwts.claims().setSubject(username);
        Date now = new Date();
        Date validity = new Date(now.getTime() + VALIDITY_IN_MILLISECONDS);
        return Jwts.builder()
                .setClaims(claims)
                .setIssuedAt(now)
                .setExpiration(validity)
                .signWith(SignatureAlgorithm.HS256, SECRET_KEY)
                .compact();
    }

    public boolean validateToken(String token) {
        try {
            Jwts.parser().setSigningKey(SECRET_KEY).parseClaimsJws(token);
            return true;
        } catch (JwtException | IllegalArgumentException e) {
            return false;
        }
    }

    public Authentication getAuthentication(String token) {
        String username = Jwts.parser().setSigningKey(SECRET_KEY).parseClaimsJws(token).getBody().getSubject();
        User user = userService.loadUserByUsername(username);
        return new UsernamePasswordAuthenticationToken(user, "", user.getAuthorities());
    }

    public String resolveToken(HttpServletRequest request) {
        String bearerToken = request.getHeader("Authorization");
        if (bearerToken != null && bearerToken.startsWith("Bearer ")) {
            return bearerToken.substring(7);
        }
        return null;
    }
}

在上面的实现中，我们使用Jwts类从JWT库创建JWT令牌。在createToken方法中，我们设置了JWT的主题，生成了签名日期和有效期，并使用秘钥对JWT进行签名。在validateToken方法中，我们验证JWT是否有效，如果有效则返回true，否则返回false。在getAuthentication方法中，我们从JWT中提取用户名，然后使用UserDetailsService加载相应的用户对象。最后，在resolveToken方法中，我们从请求头中提取JWT令牌。

在我们的微服务应用程序中，我们可以使用这些组件来实现安全和认证。下面是一个示例：

@Configuration
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {

    @Autowired
    private UserDetailsService userDetailsService;

    @Autowired
    private JwtTokenProvider jwtTokenProvider;

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.csrf().disable()
                .authorizeRequests()
                .antMatchers("/auth/**").permitAll()
                .anyRequest().authenticated()
                .and()
                .addFilterBefore(new JwtAuthenticationFilter(jwtTokenProvider), UsernamePasswordAuthenticationFilter.class);
    }

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

    @Bean
    public PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();
    }

    @Bean
    @Override
    public AuthenticationManager authenticationManagerBean() throws Exception {
        return super.authenticationManagerBean();
    }

    @Bean
    public JwtTokenProvider jwtTokenProvider() {
        return new JwtTokenProvider(userDetailsService);
    }
}

在上面的配置中，我们注入了UserDetailsService和JwtTokenProvider，并将它们用于配置Spring Security。还添加了一个密码编码器，用于编码和解码密码。最后，我们将JwtAuthenticationFilter添加到Spring Security过滤器链中，并将JwtTokenProvider定义为一个Spring Bean。

在上面的配置中，我们还实现了一个UserDetailsService，用于从数据库中加载用户对象。下面是一个示例：

@Service
public class UserService implements UserDetailsService {

    @Autowired
    private UserRepository userRepository;

    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
        User user = userRepository.findByUsername(username);
        if (user == null) {
            throw new UsernameNotFoundException("User not found");
        }
        return new org.springframework.security.core.userdetails.User(user.getUsername(), user.getPassword(), user.getAuthorities());
    }
}

在上面的实现中，我们从数据库中查找用户名，并使用User对象返回一个Spring Security用户对象。

原创声明：本文系作者授权腾讯云开发者社区发表，未经许可，不得转载。

如有侵权，请联系 cloudcommunity@tencent.com 删除。

spring cloud