Spring JPA + JWT로 로그인 구현하기(3) - Configuration 구현

Configuration 구현

AuthenticationConfig

스프링 시큐리티의 기본적인 웹 보안 활성화하고, 메서드를 재정의하여 인증과 권한을 설정할 수 있는 설정파일

package com.jh.jwt.configuration;

import com.jh.jwt.exception.JwtExceptionFilter;
import com.jh.jwt.utils.TokenProvider;
import lombok.RequiredArgsConstructor;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.http.HttpMethod;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.config.http.SessionCreationPolicy;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.web.SecurityFilterChain;
import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;

@Configuration
@EnableWebSecurity
@RequiredArgsConstructor
public class AuthenticationConfig {

    private final TokenProvider tokenProvider;

    // 비밀번호 인코딩에 BcryptPasswordEncoder 사용
    @Bean
    public BCryptPasswordEncoder encodePassword() {
        return new BCryptPasswordEncoder();
    }

    @Bean
    public SecurityFilterChain securityFilterChain(HttpSecurity httpSecurity) throws Exception {
        return httpSecurity
                // JWT를 사용하기 때문에 httpBasic, csrf를 disable
                .httpBasic().disable()
                .csrf().disable()
                .cors().and()
                .authorizeRequests()
                // API 경로 설정
                .antMatchers("/api/v1/users/login").permitAll() // 권한없이 사용할 수 있는 api
                .antMatchers("/api/v1/users/sign").permitAll() // 권한없이 사용할 수 있는 api
                .antMatchers(HttpMethod.POST, "/api/v1/reviews").authenticated() // JWT인증이 필요한 api

                // 세션도 사용하지 않기때문에 STATELESS로 설정
                .and()
                .sessionManagement()
                .sessionCreationPolicy(SessionCreationPolicy.STATELESS)

                .and()
                // 필터를 거치기 이전에 JwtFilter를 먼저 거치도록 설정
                .addFilterBefore(new JwtFilter(tokenProvider), UsernamePasswordAuthenticationFilter.class)
                // Jwt 필터를 거치기 전에 Exception 관리를 위해 JwtException Filter를 등록
                .addFilterBefore(new JwtExceptionFilter(), JwtFilter.class)
                .build();
    }
}

• @EnableWebSecurity는 스프링 스큐리티의 기본적인 웹 보안을 활성화 합니다.
• 추가로 antMathcer.hasRole("ADMIN")을 이용하면 ADMIN권한을 가진사람만 api를 사용할 수 있도록 설정할 수 있다.

TokenProvider

토큰을 생성하고 검증하는 역할과 토큰의 정보를 꺼내는 역할을 수행

package com.jh.jwt.utils;

import com.jh.jwt.domain.CustomUserDetails;
import com.jh.jwt.exception.NotLoggedInException;
import io.jsonwebtoken.*;
import io.jsonwebtoken.security.Keys;
import io.jsonwebtoken.security.SignatureException;
import org.springframework.http.HttpHeaders;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.authority.SimpleGrantedAuthority;
import org.springframework.util.StringUtils;

import javax.servlet.http.HttpServletRequest;
import java.security.Key;
import java.util.*;
import java.util.stream.Collectors;

public class TokenProvider {

    protected final String secret;
    protected final String refreshSecret;

    protected final long accessTokenExpired;
    protected final long refreshTokenExpired;

    private final RedisUtil redisUtil;

    protected Key accessKey;
    protected Key refreshKey;
    public TokenProvider(String secret, Long expiredMs, String refreshSecret, Long refreshTokenExpired, RedisUtil redisUtil){
        this.secret = secret;
        this.accessTokenExpired = expiredMs;
        this.refreshSecret = refreshSecret;
        this.refreshTokenExpired = refreshTokenExpired;

        byte[] accessKeyBytes = Base64.getDecoder().decode(secret);
        this.accessKey = Keys.hmacShaKeyFor(accessKeyBytes);

        byte[] refreshKeyBytes = Base64.getDecoder().decode(refreshSecret);
        this.refreshKey = Keys.hmacShaKeyFor(refreshKeyBytes);

        this.redisUtil = redisUtil;
    }

    // Access 토큰에서 사용자명 반환
    public String getUsername(String token) {
        return Jwts.parserBuilder().setSigningKey(accessKey).build().parseClaimsJws(token).getBody().get("username", String.class);
    }

    // Refresh토큰에서 사용자명 반환
    public String getRefreshUsername(String token) {
        return Jwts.parserBuilder().setSigningKey(refreshKey).build().parseClaimsJws(token).getBody().get("username", String.class);
    }

    // 토큰에서 권한정보 반환
    public Collection<? extends GrantedAuthority> getAuthority(String token) {
        Claims claims = Jwts.parserBuilder().setSigningKey(accessKey).build().parseClaimsJws(token).getBody();
        return Arrays.stream(claims.get("auth").toString().split(","))
                .map(SimpleGrantedAuthority::new)
                .collect(Collectors.toList());
    }

    // Access 토큰 생성
    public String createAccessJwt(CustomUserDetails principal) {
        Claims claims = Jwts.claims();
        claims.put("username", principal.getUsername());
        claims.put("auth", principal.getAuthorities());

        return  Jwts.builder()
                .setClaims(claims)
                .setIssuedAt(new Date(System.currentTimeMillis()))
                .setExpiration(new Date(System.currentTimeMillis() + accessTokenExpired))
                .signWith(accessKey, SignatureAlgorithm.HS512)
                .compact();
    }

    // Refresh 토큰 생성
    public String createRefreshJwt(CustomUserDetails principal) {
        Claims claims = Jwts.claims();
        claims.put("username", principal.getUsername());

        return  Jwts.builder()
                .setClaims(claims)
                .setIssuedAt(new Date(System.currentTimeMillis()))
                .setExpiration(new Date(System.currentTimeMillis() + refreshTokenExpired))
                .signWith(refreshKey, SignatureAlgorithm.HS512)
                .compact();
    }

    // 헤더 Authorization에서 토큰정보 추출
    public String resolveToken(HttpServletRequest request) {
        String bearerToken = request.getHeader(HttpHeaders.AUTHORIZATION);
        if (StringUtils.hasText(bearerToken) && bearerToken.startsWith("Bearer ")) {
            return bearerToken.substring(7);
        }
        return null;
    }
    // Access토큰 토큰 유효성 검사
    public boolean validateToken(String token) {
        try {
            Claims claims = Jwts.parserBuilder().setSigningKey(accessKey).build().parseClaimsJws(token).getBody();
            if (redisUtil.hasKeyBlackList(token)) {
                throw new SignatureException("로그인을 해주세요.");
            }
            return true;
        } catch(MalformedJwtException | SignatureException e) {
            throw new MalformedJwtException("잘못된 JWT 서명입니다.");
        } catch(ExpiredJwtException e) {
            throw new ExpiredJwtException(e.getHeader(), e.getClaims(), "만료된 JWT 토큰입니다.");
        } catch(UnsupportedJwtException e) {
            throw new UnsupportedJwtException("지원하지 않는 JWT 토큰입니다.");
        } catch(IllegalArgumentException e) {
            throw new IllegalArgumentException("JWT 토큰이 잘못되었습니다.");
        }
    }

    // Refresh 토큰 유효성 검사
    public boolean validateRefreshToken(String token) {
        try {
            Claims claims = Jwts.parserBuilder().setSigningKey(refreshKey).build().parseClaimsJws(token).getBody();
            return true;
        } catch(MalformedJwtException | SignatureException  |  ExpiredJwtException |  UnsupportedJwtException | IllegalArgumentException e) {
            System.out.println("e = " + e);
            throw new NotLoggedInException("로그인을 해주세요.");
        }
    }

}

JwtFilter

실직적인 인증절차를 진행하는 설정파일

package com.jh.jwt.configuration;

import com.jh.jwt.utils.TokenProvider;
import lombok.RequiredArgsConstructor;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.http.HttpHeaders;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.security.web.authentication.WebAuthenticationDetailsSource;
import org.springframework.util.StringUtils;
import org.springframework.web.filter.OncePerRequestFilter;

import javax.servlet.FilterChain;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.*;

// 토큰 인증 계층
@RequiredArgsConstructor
public class JwtFilter extends OncePerRequestFilter {
    protected final Logger logger = LoggerFactory.getLogger(JwtFilter.class);
    private final TokenProvider tokenProvider;

    @Override
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException {
            // authorization이 null이면 SecurityFilterChain을 거치도록한다.
            final String authorization = request.getHeader(HttpHeaders.AUTHORIZATION);
            if(authorization == null){
                filterChain.doFilter(request, response);
                return;
            }
            String token = tokenProvider.resolveToken(request);
            if (tokenProvider.validateToken(token)){

                // Username, Authorities Token에서 꺼내기
                String username = tokenProvider.getUsername(token);
                Collection<? extends GrantedAuthority>  authority = tokenProvider.getAuthority(token);
                logger.info("username: {}", username);
                logger.info("authority: {}", authority);

                // 권한 부여
                UsernamePasswordAuthenticationToken authenticationToken =
                        new UsernamePasswordAuthenticationToken(username, null, authority);

                // 해당 authenticationToken을 스프링 시큐리티 컨텍스트에 저장한다.
                authenticationToken.setDetails(new WebAuthenticationDetailsSource().buildDetails(request));
                SecurityContextHolder.getContext().setAuthentication(authenticationToken);
                filterChain.doFilter(request, response);
        }
    }
}

• OncePerRequestFilter는 Request한번에 한번만 실행되는 Filter입니다.
• doFilterInternal에서 토큰의 유효성을 검증하고, 토큰에 들어있는 username과 authority를 가져와 authentication을 생성하고 스프링 시큐리티 컨텍스트에 저장하는 역할을 합니다.

JWTConfig

TokenProvider에 의존성을 주입하고 빈을 생성하는 역할을 하는 설정파일

package com.jh.jwt.configuration;

import com.jh.jwt.utils.RedisUtil;
import com.jh.jwt.utils.TokenProvider;
import lombok.RequiredArgsConstructor;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

// TokenProvider에 의존성을 주입하고 빈을 생성하는 설정 파일
@Configuration
@RequiredArgsConstructor
public class JwtConfig {

    @Value("${jwt.secret}")
    private String secret;

    @Value("${jwt.access_token_expired}")
    private Long accessTokenExpired;

    @Value("${jwt.refresh_secret}")
    private String refreshSecret;

    @Value("${jwt.refresh_token_expired}")
    private Long refreshTokenExpired;

    private final RedisUtil redisUtil;

    @Bean(name = "tokenProvider")
    public TokenProvider tokenProvider() {
        return new TokenProvider(secret, accessTokenExpired, refreshSecret, refreshTokenExpired, redisUtil);
    }
}

참고

멋사 SpringSecurity 인증인가 - 04 Token유효한지 만료되었는지 검사하기
https://velog.io/@suhongkim98/Spring-Security-JWT로 인증인가구현하기