둔필승총

이전에 웹 브라우저의 세션을 이용해서 로그인과 회원가입을 구현하고 쿠키에 저장하는 방법을 통하여 로그인 회원가입을 처리해본 경험이 있다.
하지만 세션과 쿠키를 사용하는 것에는 단점들이 있다. 먼저 jwt는 STATELESS하므로 상태를 저장하지 않는 RESTful API에 적합하였고, 모바일 환경에서도 쉽게 사용할 수 있다는 장점이 있었다.

해당 내용을 바탕으로 JWT와 스프링 시큐리티를 사용하여 로그인, 회원가입, JWT 토큰을 이용한 나의 정보 확인 이렇게 3가지 기능을 동작하도록 만들었다.

먼저 3가지 기능에 해당하는 내가 만든 API endpoint는 다음과 같다.

1. /members/login
2. /members/signup
3. /members/check

이제 스프링 시큐리티와 JWT를 알아보면서 해당 기능들을 구현해보겠다.

스프링 시큐리티, 사용이유

원리 : 서블릿 필터를 이용한다.

Spring의 내부 원리는 사용자(client)가 api를 호출하면 servlet container(tomcat)가 받고, request 받은 것을 spring의 dispatcherservlet에게 요청하게 된다. 요청에 따라서 controller에게 전달하고 서블릿 컨테이너가 응답을 받아서 사용자에게 전달한다.

servlet container에서 spring dispatcher servlet까지 전달될때까지 개입을 할 수 있는데, 개입을 필터를 적용해서 할 수 있다. 즉, servlet 객체들이 dispatcher servlet에 도착하기 전에 필터체인을 통과한 뒤에 dispatcherservlet에 도착하게 되는 것이다.

따라서 필터에서는 DispatcherServlet의 빈에 직접적으로 접근할 수 없다. 그러나 Spring Security의 SecurityFilterChain을 사용하는 경우에는 DispatcherServlet의 빈에 접근할 수 있다.

Spring Security는 내부적으로 DispatcherServlet과 연동하여 보안 관련 작업을 처리하기 때문에, 필터 체인을 통과한 후에 DispatcherServlet의 빈에 접근할 수 있다. 스프링 시큐리티와 DispatcherServlet 간에는 위임이 필요하며, SecurityFilterChain을 통해 이러한 위임이 이루어진다.

(chain이라는 말은 여러 개의 연결고리라는 뜻인데, 필터를 여러 가지 등록하는 것을 chain을 따라 인증을 진행한다고 생각하면 된다.)

개발자가 spring security를 해서 구현하는 방법이 여러 가지이다. filter 자체를 이해해서 filter를 구현하는 방법이 있고, 필터에서 돌아가는 여러 가지 함수 메소드들을 오버라이딩해서 일부를 커스터마이징할 수도 있다. (나는 일부 흐름만 커스터마이징하였다.)

JWT

JWT는 JSON Web Token의 약자이다. 정보를 JSON 형태로 전송하는 토큰이라는 의미이다. JWT는 URL로 이용할 수 있는 문자열로만 구성되어 있고 서버와의 통신에서 사용된다.

JWT의 구조

• 헤더(Header) : 검증과 관련된 내용, 해싱 알고리즘과 토큰 타입 지정
• 내용(Payload) : 토큰에 담는 정보. 여기에 포함된 속성들은 클레임이라고 한다.
• 서명(Signature) : 인코딩된 헤더, 인코딩된 내용, 비밀키, 헤더의 알고리즘으로 서명이 생성됨.

https://jwt.io/#debugger-io
여기에 들어가면 JWT를 생성할 수 있고 디코딩된 정보도 볼 수 있다.

스프링 시큐리티와 JWT 적용하기

UsernamePasswordAuthenticationFilter를 통한 인증 과정

1. 클라이언트가 사용자의 아이디와 비밀번호를 포함한 인증 요청을 서버로 전송한다.
2. 요청을 받게 되면 서블릿 필터에서 SecurityFilterChain으로 작업이 위임된다. (DispatcherServlet의 bean에 접근하기 위해)
3. SecurityFilterChain 중에서 AuthenticationFilter에서 인증을 처리한다. 아무 설정하지 않았으면 AuthenticationFilter 중에서 UsernamePasswordAuthenticationFilter가 인증을 처리한다.
4. AuthenticationFilter는 요청받은 username이랑 password를 가지고 UsernamePasswordAuthenticationToken에서 토큰을 생성한다.
5. 그러면 만든 토큰을 AuthenticationManager에게 전달한다. AuthenticationManager는 인터페이스이고 이를 구현한 것은 ProvideManager이다.
6. ProvideManager는 인증을 해주어야 하기 때문에 AuthenticationProvider로 토큰을 전달한다. 해당 Provider에서 인증을 수행하고 성공하게 되면 ProvideManager로 권한을 담은 토큰을 전달한다.
7. AuthenticationProvider는 UserDetailsService에 토큰의 정보를 전달한다.
8. UserDetailsService는 전달받은 정보를 통해 데이터베이스에서 일치하는 사용자를 찾아서 UserDetails 객체를 생성한다
9. 생성된 UserDetails객체는 다시 AuthenticationProvider로 전달되고, Provider에서 인증이 성공하면 ProviderManager로 권한을 담은 토큰을 전달하게 된다.
10. 그럼 ProviderManager는 다시 검증된 토큰을 AuthenticationFilter로 전달한다.
11. AuthenticationFilter는 토큰을 SecurityContextHolder에 있는 SecurityContext에 저장한다.

UsernamePasswordAuthenticationFilter는 접근 권한을 확인하고 인증이 실패할 경우 화면을 보내는 역할을 한다.

이전에 SpringSecurity와의 변경점(feat. WebSecurityConfigureAdapter 상속받는 방법 없어짐)

스프링 공식문서에 나와있는 JWT 적용방식을 응용하여서 구현해보겠다. JWT 샘플코드는 아래의 것을 사용하였다.
https://github.com/spring-projects/spring-security-samples/tree/main/servlet/spring-boot/java/jwt/login

SecurityConfiguration 구현

일단 책이랑 정보를 찾아보았을 때 WebSecurityConfigureAdapter를 상속받아서 스프링 시큐리티를 설정한다고 하였으나 실제로 IntelliJ에서 해당 클래스가 deprecated되어서 현재는 위의 document를 응용해서 구현하였다. (Security 5.7부터 바뀌었다고 한다)
Spring Blog에도 해당 내용이 나와있다.
https://spring.io/blog/2022/02/21/spring-security-without-the-websecurityconfigureradapter
(기존에는 WebSecurityConfigurerAdapter를 상속받아 설정을 오버라이딩 하는 방식이었는데 바뀐 방식에서는 상속받아 오버라이딩하지 않고 모두 Bean으로 등록을 한다.)

document에서는 authorize.anyRequest().authentication()으로 되어있다. 그렇게 되면 로그인 하지 않으면, 권한이 없으므로 login 페이지로 계속 이동하기 때문에 일단 permitAll()을 해놓고 login 페이지가 잘 보이는 것을 확인하고 구현을 시작하였다. 공식문서의 SecurityConfig 페이지는 아래와 같고, 여기서 rule을 추가시키겠다.

@Configuration  
public class SecurityConfig {  
    @Bean  
    public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {  
    http  
        .authorizeHttpRequests((authorize) -> authorize  
        .anyRequest().permitAll()  
    )  
        .httpBasic(withDefaults())  
        .formLogin(withDefaults());  
    return http.build();  
    }  
}

Rule 추가하기

위의 코드에서는 anyRequest()가 되어 있어서 어떤 url이든 인증이 필요하다. anyRequest()를 mvcMatchers()(아니면 antMatchers사용)를 사용하고 안에 parameter로 url을 넣을수도 있고, 아니면 HTTPMethod중 GET이나 POST 같은 것들로 지정해줄 수도 있다. 로그인과 회원가입, swagger 문서들은 jwt 토큰이 있을 수가 없다. 그래서 해당 url은 인증의 범위에서 제외시켜주었다.

// SecurityConfig
@Configuration
@EnableWebSecurity
@RequiredArgsConstructor
public class SecurityConfig {

    private final JwtTokenProvider jwtTokenProvider;

    @Bean
    public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
        http
                .httpBasic().disable()
                .csrf().disable()
                .sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS)
                .and()
                .authorizeRequests()
                .antMatchers("/members/login").permitAll()
                .antMatchers("/members/signup").permitAll()
                .antMatchers("/members/check").permitAll()
                .antMatchers("/swagger-ui/index.html").permitAll()
                .anyRequest().authenticated()
                .and()
                    .addFilterBefore(new JwtAuthenticationFilter(jwtTokenProvider), UsernamePasswordAuthenticationFilter.class);
        return http.build();
    }

    @Bean
    public PasswordEncoder passwordEncoder() {
        return PasswordEncoderFactories.createDelegatingPasswordEncoder();
    }
}

• httpBasic().disable() : Spring Securtiy를 처음 의존성을 추가하면 BASE64를 이용하여 비밀번호가 나온다(https://jobdong7757.tistory.com/205 참고) 그걸 disable하는 내용이다. (사용안하고 jwt 사용할 거니까)
• csrf().disalbe() : 쿠키 기반이 아니라 jwt 기반이므로 사용하지 않는다
• `sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS) : Spring Security 세션 정책 : 세션을 생성 및 사용하지 않는다.
• antMatchers({허용할 endpoint}) : 여기에는 인증이 필요없는 endpoint를 작성해서 permitAll() 해주면 된다.
• addFilterBefore(new JwtAuthenticationFilter(jwtTokenProvider), UsernamePasswordAuthenticationFilter.class) : JWT 인증 필터를 UsernamePasswordAuthenticationFilter.class 앞에 적용하겠다는 의미로 jwtTokenProvider를 이후에 작성할 예정이다.

PasswordEncoder

PasswordEncoder는 스프링 시큐리티에서 비밀번호를 안전하게 저장하고 검증하기 위해 사용되는 인터페이스이다. PasswordEncoder를 구현한 구체적인 클래스는 비밀번호를 해싱하고, 솔트(salt)를 적용한다.

PasswordEncoderFactories.createDelegatingPasswordEncoder()는 스프링 시큐리티에서 제공하는 PasswordEncoder의 구현체를 생성하는 메서드이다. 이 메서드는 현재 스프링 시큐리티의 기본 비밀번호 인코더를 생성하고 반환한다.

주로 사용자의 비밀번호를 저장하기 전에 해당 비밀번호를 해싱하여 안전하게 저장하고, 로그인 시 비밀번호를 검증하는 등의 작업에 PasswordEncoder를 사용할 수 있다.

jwt 토큰과 jwt 인증 필터를 어떻게 사용하면 될까

jwt 토큰을 어떻게 사용할지 정리해보겠다. (이메일을 아이디처럼 사용할 것이다. 회원의 데이터베이스에 id로 저장되는 것과 다른 것이다.)
먼저, 회원가입을 할 때는 이메일과 비밀번호만 받으면 된다. 해당 정보를 입력하였을 때, 나는 회원가입이 성공하면 id, 이메일, 생성시간 3가지를 전달받는다.

그리고 로그인을 할 때는 이메일, 비밀번호를 입력하면 된다. 그럼 나는 반환 값으로 이메일, grantType(여기서는 Bearer), accessToken, refreshToken같은 인증 토큰을 전달받으면 된다.

그럼 이후부터 api 요청을 할 때, accessToken을 header에 넣어서 보내야 api가 요청이 되게 한다. 그 의미는 인증된 사용자라는 뜻이기 때문이다.

accessToken과 refreshToken을 따로 두는 것은, accessToken이 탈취될 위험이 있기 때문에, accessToken의 기한을 짧게 두고 해당 기한이 만료되면 새로 발급받기 위해 기한이 긴 refresToken을 이용해서 새로 발급받으면 되기 때문이다.

그럼 하나하나 구현을 해보겠다.

Member Controller 구성

먼저 로그인이랑 회원가입을 할 수 있도록 controller를 구성한 다음, service를 구현할 생각을 하였다. (맨 처음에 적용할 endpoint 적용)

@RestController
@RequiredArgsConstructor
@RequestMapping("/members")
public class MemberController {
    private final MemberService memberService;

    @PostMapping("/login")
    @ResponseStatus(HttpStatus.ACCEPTED)
    public MemberLoginResponseDto login(@RequestBody MemberLoginRequestDto memberLoginRequestDto) {
        String email = memberLoginRequestDto.getEmail();
        String password = memberLoginRequestDto.getPassword();
        return memberService.login(email, password);
    }

    @PostMapping("/signup")
    @ResponseStatus(HttpStatus.CREATED)
    public MemberSignUpResponseDto signup(@Valid @RequestBody MemberSignUpRequestDto memberSignUpRequestDto) {
        String email = memberSignUpRequestDto.getEmail();
        String password = memberSignUpRequestDto.getPassword();
        return memberService.signup(email, password);
    }

    @GetMapping("/check")
    @ResponseStatus(HttpStatus.OK)
    public MemberSignUpResponseDto checkMember(HttpServletRequest request) {
        return memberService.checkMember(request);
    }

}

회원가입

회원가입을 먼저 구현해 보겠다. 위의 controller에서 memberService의 signup함수를 구현하면 된다.
일단 중복 이메일을 체크해야 하므로, 중복된 이메일을 처리해주었다. 그리고 아직은 role에 대한 것을 해야할 요구조건이 없으므로 Role은 USER로 저장해주었다. (그럼 모든 권한이 가능하게 아래에서 처리하게 하였다.)

// MemberService의 signup 함수
    @Transactional
    public MemberSignUpResponseDto signup(String email, String password) {
        // 중복된 이메일 체크
        if (memberRepository.findByEmail(email).isPresent()) {
            throw new RuntimeException("중복된 이메일이 존재합니다");
        }
        Member member = Member.builder()
                .email(email)
                .password(password)
                .createdAt(LocalDateTime.now())
                .updatedAt(LocalDateTime.now())
                .build();
        Member savedMember = memberRepository.save(member);
        MemberSignUpResponseDto responseDto = new MemberSignUpResponseDto(savedMember.getId(), savedMember.getEmail(), savedMember.getCreatedAt());
        return responseDto;
    }

먼저 중복된 이메일을 체크하고, Member 도메인의 builder 패턴으로 입력받은 이메일과 비밀번호로 만들어준다.

@Getter
@Builder
@NoArgsConstructor
@AllArgsConstructor
@Entity
public class Member extends BaseEntity {
    @Id @Column(updatable = false, unique = true, nullable = false, length = 250)
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column(nullable = false, length = 100)
    private String email;

    @Column(nullable = false, length = 250)
    private String password;

    @CreatedDate
    @DateTimeFormat(iso = DateTimeFormat.ISO.DATE_TIME)
    LocalDateTime createdAt;

    @LastModifiedDate
    @DateTimeFormat(iso = DateTimeFormat.ISO.DATE_TIME)
    LocalDateTime updatedAt;

    @Builder
    public Member(String email, String password, LocalDateTime createdAt, LocalDateTime updatedAt) {
        this.email = email;
        this.password = password;
        this.createdAt = createdAt;
        this.updatedAt = updatedAt;
    }
}

UserDetails
UserDetails 인터페이스는 스프링 시큐리티에서 사용자의 정보와 권한을 제공하기 위한 인터페이스이다. 사용자의 인증과 권한 부여를 처리하는 과정에서 스프링 시큐리티가 UserDetails 객체를 통해 사용자 정보를 관리하고 제공한다. (하지만, 현재로서는 권한을 부여할 필요는 없어서 해당 내용은 제외하였다.)

UserDetails 인터페이스는 다음과 같은 주요 메서드를 정의하고 있다.

1. getUsername(): 사용자의 고유한 식별자인 사용자 이름을 반환
2. getPassword(): 사용자의 비밀번호를 반환
3. getAuthorities(): 사용자의 권한 목록을 반환. 각 권한은 GrantedAuthority 인터페이스를 구현한 객체로 표현된다.
4. isAccountNonExpired(): 사용자 계정의 유효 기간이 만료되었는지 여부를 반환
5. isAccountNonLocked(): 사용자 계정이 잠겨있는지 여부를 반환
6. isCredentialsNonExpired(): 사용자의 인증 정보(비밀번호)의 유효 기간이 만료되었는지 여부를 반환
7. isEnabled(): 사용자 계정이 활성화되었는지 여부를 반환

UserDetails 인터페이스를 통해 애플리케이션에서 보안 관련 작업을 보다 쉽게 구현할 수 있다.

로그인 구현하기

로그인은 이메일과 비밀번호를 받으면 인증을 처리하고 jwt token을 만들어주어야 하기 때문에 처음 배우는 부분이 많았다. 하나하나 차례대로 보겠다.

MemberService에 있는 login함수

@Transactional  
public MemberLoginResponseDto login(String email, String password) {  
    // 1. Login ID/PW 를 기반으로 Authentication 객체 생성  
    // 이때 authentication 는 인증 여부를 확인하는 authenticated 값이 false
    UsernamePasswordAuthenticationToken authenticationToken = new UsernamePasswordAuthenticationToken(email, password);  

    // 2. 실제 검증 (사용자 비밀번호 체크)이 이루어지는 부분  
    // authenticate 매서드가 실행될 때 CustomUserDetailsService 에서 만든 loadUserByUsername 메서드가 실행  
    Authentication authentication = authenticationManagerBuilder.getObject().authenticate(authenticationToken);  

    // 3. 인증 정보를 기반으로 JWT 토큰 생성  
    TokenInfo tokenInfo = jwtTokenProvider.generateToken(authentication);  

    return new MemberLoginResponseDto(email, tokenInfo.getGrantType(), tokenInfo.getAccessToken(), tokenInfo.getRefreshToken());  
}

• UsernamePasswordAuthenticationToken authenticationToken = new UsernamePasswordAuthenticationToken(email, password) : UsernamePasswordAuthenticationToken 객체는 사용자의 인증 정보를 담고 있으며, 인증 매니저에게 전달하여 실제로 사용자를 인증하는 과정에서 사용된다.
• Authentication authentication = authenticationManagerBuilder.getObject().authenticate(authenticationToken); :
  AuthenticationFilter는 생성한 authenticationToken AuthenticationManager에게 전달한다. AuthenticationManager은 실제로 인증을 처리할 여러개의 AuthenticationProvider를 가지고 있다. 그럼 UserDetailService에서 해당 내용을 기반으로 조회를 한다.

UsernamePasswordAuthenticationToken 클래스
UsernamePasswordAuthenticationToken은 스프링 시큐리티에서 사용자의 인증을 처리할 때 사용되는 객체이다. 주로 사용자가 제출한 아이디(여기서는 email)와 비밀번호(password) 정보를 포함하여 인증 작업에 필요한 정보를 전달하는 데 사용된다.

UsernamePasswordAuthenticationToken은 인증 매커니즘에서 인증을 수행하는 과정에서 생성되고 사용된다. 일반적으로 사용자가 로그인 페이지에서 사용자 이름과 비밀번호를 입력하면, 스프링 시큐리티는 UsernamePasswordAuthenticationToken 객체를 생성하여 사용자가 제출한 인증 정보를 담아 인증 처리를 시작한다.

UsernamePasswordAuthenticationToken은 Authentication 인터페이스를 구현한 클래스로, 사용자의 인증 정보를 담고 있다. Authentication은 스프링 시큐리티에서 인증에 필요한 정보를 캡슐화하는 인터페이스이다.

UsernamePasswordAuthenticationToken은 주로 AuthenticationManager에 의해 처리되며, 인증 과정에서 제공된 사용자 이름과 비밀번호를 사용하여 사용자를 인증한다. 인증이 성공하면 Authentication 객체가 인증된 상태로 반환되고, 인증 실패시에는 예외가 발생할 수 있다.

CustomUserDetailsService

@Service
@RequiredArgsConstructor
public class CustomUserDetailsService implements UserDetailsService {

    private final MemberRepository memberRepository;
    private final PasswordEncoder passwordEncoder;

    @Override
    public UserDetails loadUserByUsername(String email) throws RuntimeException {
        return memberRepository.findByEmail(email)
                .map(this::createUserDetails)
                .orElseThrow(() -> new RuntimeException("해당하는 유저를 찾을 수 없습니다."));
    }

    // 해당하는 User 의 데이터가 존재한다면 UserDetails 객체로 만들어서 리턴
    private UserDetails createUserDetails(Member member) {
        return User.builder()
                .username(member.getEmail())
                .password(passwordEncoder.encode(member.getPassword()))
                .build();
    }
}

CustomUserDetailsService 클래스가 Authentication authentication = authenticationManagerBuilder.getObject().authenticate(authenticationToken); 에서 동작되는 원리

1. AuthenticationManager는 인증 요청에 필요한 사용자 정보를 DB에서 가져와야 한다. 이때 loadUserByUsername 메서드가 호출된다.
2. loadUserByUsername 메서드는 UserDetailsService 인터페이스를 구현한 CustomUserDetailsService에서 구현된다. 해당 메서드는 주어진 사용자 이름(username)을 기반으로 사용자 정보를 조회하고, UserDetails 객체를 반환한다.
3. AuthenticationManager는 loadUserByUsername 메서드를 통해 반환된 UserDetails 객체를 사용하여 인증 과정을 진행한다. 인증 과정에서는 사용자가 입력한 인증 정보와 UserDetails 객체에 저장된 정보를 비교하여 인증을 수행한다.
4. AuthenticationManager는 인증 결과인 Authentication 객체를 생성하여 반환한다. 이때 Authentication 객체는 인증된 사용자 정보와 권한 정보를 포함한다.

이제 DB에 사용자가 있다는 사실을 인증받은 것이므로 해당 내용을 바탕으로 jwtToken을 생성하는 jwtTokenprovider를 만들면 된다.

토큰 정보 클래스 만들기

클라이언트가 요청하면 서버는 jwt token을 클라이언트에게 response로 주어야 한다.
해당 정보를 클래스로 만들어보자.

@Builder  
@Data  
@AllArgsConstructor  
public class TokenInfo {  
    private String grantType;  // Bearer
    private String accessToken;  
    private String refreshToken;  
}

grantType
grant typedms 클라이언트가 어떤 유형의 인증 흐름을 사용하여 액세스 토큰을 요청하는지 나타낸다.
그 중에서 Bearer를 사용할 건데, Bearer 토큰은 서버에 상태를 저장하지 않고, 클라이언트가 요청을 보낼 때마다 토큰의 유효성을 검증한다. 그래서 이후에 HTTP 요청을 보낼때 헤더에 붙여서 보내면 인증된 사용자인지 검증할 수 있는 것이다.

JwtTokenProvider 클래스

JwtTokenProvider는 사용자 인증과 인가를 처리하는 데 사용되는 클래스이다. JWT (JSON Web Token)을 생성, 유효성 검사 및 해석하는 데 사용되고, 주로 Spring Security와 함께 사용되며, 사용자의 인증 정보를 JWT 토큰으로 인코딩하여 전달하고, 토큰의 유효성을 검사하여 사용자를 인증하고 권한을 부여한다. secret key를 사용해서 jwt token을 만들 것이다.

yml 파일에 secret key 추가

토큰을 암호화하고 복호화할 때 HS256 알고리즘을 사용하려면 secret key를 설정해주어야 한다. 해당 코드를 yml 파일에 적어주자. (아무거나 해당 길이만 맞으면 된다!)

jwt:  
    secret: VlwEyVBsYt9V7zq57TejMnVUyzblYcfPQye08f7MGVA9XkHa

JwtTokenProvider 클래스

// 토큰 생성  
@Slf4j
@Component
public class JwtTokenProvider {

    private final Key key;

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

    private final long at_exp = 1000L * 60 * 30;
    private final long rt_exp = 1000L & 60 * 60;
    // secret key를 가지고 key값 저장
    public JwtTokenProvider(@Value("${jwt.secret}") String salt) {
        this.key = Keys.hmacShaKeyFor(salt.getBytes(StandardCharsets.UTF_8));
    }

    // 토큰 생성
    public TokenInfo generateToken(Member member) {
        // Access Token 생성
        Claims claims = Jwts.claims().setSubject(member.getEmail());
        claims.put("memberId", member.getId());

        long now = (new Date()).getTime();
        Date accessTokenExpiresIn = new Date(now + at_exp);
        String accessToken = Jwts.builder()
                .setClaims(claims)
                .setExpiration(accessTokenExpiresIn)
                .signWith(key, SignatureAlgorithm.HS256)
                .compact();

        // Refresh Token 생성
        String refreshToken = Jwts.builder()
                .setExpiration(new Date(now + rt_exp))
                .signWith(key, SignatureAlgorithm.HS256)
                .compact();

        return TokenInfo.builder()
                .grantType("Bearer")
                .accessToken(accessToken)
                .refreshToken(refreshToken)
                .build();
    }

    // JWT 토큰을 복호화하여 토큰에 들어있는 정보를 꺼내는 메서드
    public Authentication getAuthentication(String accessToken) {
        // 토큰 복호화
        Claims claims = parseClaims(accessToken);

        // UserDetails 객체를 만들어서 Authentication 리턴
        UserDetails principal = new User(claims.getSubject(), "", Collections.emptyList());
        return new UsernamePasswordAuthenticationToken(principal, "", Collections.emptyList());
    }

    // 토큰 정보를 검증하는 메서드
    public boolean validateToken(String token) {
        try {
            Jwts.parserBuilder().setSigningKey(key).build().parseClaimsJws(token);
            return true;
        } catch (RuntimeException e) {
            throw e;
        }

    }

    private Claims parseClaims(String accessToken) {
        try {
            return Jwts.parserBuilder().setSigningKey(key).build().parseClaimsJws(accessToken).getBody();
        } catch (RuntimeException e) {
            throw e;
        }
    }

    // Bearer 제외부분
    public String getToken(String token) {
        token = token.substring(7).trim();
        return token;
    }

    public String getEmail(String token) {
        return Jwts.parserBuilder().setSigningKey(salt.getBytes()).build().parseClaimsJws(token).getBody().getSubject();
    }

    public String resolveToken(HttpServletRequest request) {
        return request.getHeader("Authorization");
    }
}

1. authentication.getAuthorities()를 통해 사용자의 권한 정보를 가져온다. 권한은 GrantedAuthority 객체로 표현되며, getAuthority()를 사용하여 권한 이름을 추출한다. 여러 권한이 있을 경우 쉼표로 구분하여 문자열로 합친다.
2. 현재 시간을 기준으로 액세스 토큰의 만료 시간을 계산한다. new Date(now + ac_exp)를 통해 현재 시간으로부터 30분 후의 시간을 나타내는 accessTokenExpiresIn을 생성한다.
3. Jwts.builder()를 사용하여 JWT 빌더를 생성한다. setSubject(authentication.getName())로 JWT의 subject(주체)를 사용자명으로 설정한다. 권한은 필요없으므로 empty로 둔다.
4. setExpiration(accessTokenExpiresIn)으로 액세스 토큰의 만료 시간을 설정한다. signWith(key, SignatureAlgorithm.HS256)로 시크릿 키와 알고리즘을 사용하여 토큰을 서명한다. compact()를 호출하여 토큰을 문자열로 변환한다.
5. refreshToken을 생성한다. 액세스 토큰과 동일한 방식으로 빌더를 생성하고, 만료 시간을 현재 시간으로부터 24시간 후로 설정한다.
6. TokenInfo 객체를 생성하고, grantType을 "Bearer"로 설정하고, 생성된 액세스 토큰과 리프레시 토큰을 할당한다.

이 코드는 사용자의 인증 정보를 JWT 토큰으로 변환하여 반환하는 메서드로, 액세스 토큰과 리프레시 토큰을 생성하여 TokenInfo 객체로 래핑하여 반환한다.

JwtAuthenticationFilter

JWT 인증을 하기 위해 사용되는 필터로 JwtAuthenticationFilter를 통과하고 UsernamePasswordAuthenticationFilter를 진행하게 된다.
해당 과정은 토큰이 유효한지 검사하고 토큰 정보를 추출하는 함수이다.

@RequiredArgsConstructor
public class JwtAuthenticationFilter extends GenericFilterBean {

    private final JwtTokenProvider jwtTokenProvider;

    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
        // 1. Request Header 에서 JWT 토큰 추출
        String token = resolveToken((HttpServletRequest) request);

        // 2. validateToken 으로 토큰 유효성 검사
        if (token != null && jwtTokenProvider.validateToken(token)) {
            // 토큰이 유효할 경우 토큰에서 Authentication 객체를 가지고 와서 SecurityContext 에 저장
            Authentication authentication = jwtTokenProvider.getAuthentication(token);
            SecurityContextHolder.getContext().setAuthentication(authentication);
        }
        chain.doFilter(request, response);
    }

    // Request Header 에서 토큰 정보 추출
    private String resolveToken(HttpServletRequest request) {
        String bearerToken = request.getHeader("Authorization");
        if (StringUtils.hasText(bearerToken) && bearerToken.startsWith("Bearer")) {
            return bearerToken.substring(7);
        }
        return null;
    }
}