[회원관리] Jwt를 활용한 회원관리 기능 세팅

로그인, 회원가입, 로그아웃과 같은 회원관리 기능을 구현하기 위해 Jwt 와 Spring Security를 사용하기로 했다.

 

Jwt(Json Web Token)란 Json 포맷을 이용하여 사용자에 대한 속성을 저장하는 Claim 기반의 Web Token이다.

Jwt는 토큰 자체를 정보로 사용하는 Self-Contained(자기참조?) 방식으로 정보를 안전하게 전달한다.

주로 회원 인증이나 정보 전달에 사용되는 Jwt는 아래의 로직을 따라서 처리하게 된다.

(사실 Jwt 이외에도 여러 회원관리 기능을 구현을 위한 기술들이 존재하지만 프로젝트를 진행하면서 가장 많이 사용해보았고, 익숙한 방법이 Jwt이다보니... 사용한 것도 큰 이유 중 하나이다....)

 

Jwt 절차

즉, 회원 정보가 존재하면 스토리지에 저장된 값을 이용해서 로그인을 바로 처리하는 것이고,

없다면 회원가입을 통해 회원정보 생성 후 로컬 스토리지에 저장하고, Jwt 발행하여 로그인을 처리한다.

 

사진에 나와있듯이 static 변수에 저장되는 이유는 HTTP 통신을 할 때마다 Jwt를 HTTP 헤더에 담아서 보내야 하는데, 이를 로컬 스토리지에서 계속 불러오면 오버헤드가 발생하기 때문이다.

클라이언트에서 Jwt를 포함해 요청을 보내면 서버는 허가된 Jwt인지를 검사한다. 또한 로그아웃을 할 경우 로컬 스토리지에 저장된 Jwt 데이터를 제거한다.

 

 

[ Jwt 구조 ]

Jwt는 Header, Payload, Signature의 3 부분으로 이루어지며, Json 형태인 각 부분은 Base64로 인코딩 되어 표현된다.

또한 각각의 부분을 이어 주기 위해 . 구분자를 사용하여 구분한다.

추가로 Base64는 암호화된 문자열이 아니고, 같은 문자열에 대해 항상 같은 인코딩 문자열을 반환한다.

 

 

1. Header(헤더)

토큰의 헤더는 typ과 alg 두 가지 정보로 구성된다. alg는 헤더(Header)를 암호화 하는 것이 아니고, Signature를 해싱하기 위한 알고리즘을 지정하는 것이다.

• typ: 토큰의 타입을 지정 ex) JWT
• alg: 알고리즘 방식을 지정하며, 서명(Signature) 및 토큰 검증에 사용 ex) HS256(SHA256) 또는 RSA

{ 
   "alg": "HS256",
   "typ": JWT
 }

 

 

2. PayLoad(페이로드)

토큰의 페이로드에는 토큰에서 사용할 정보의 조각들인 클레임(Claim)이 담겨 있다. 

클레임은 총 3가지로 나누어지며, Json(Key/Value) 형태로 다수의 정보를 넣을 수 있다.

즉, 전달 및 사용하고자 하는 메인 정보들을 담는 부분이다.

 

 

2.1 등록된 클레임(Registered Claim)

등록된 클레임은 토큰 정보를 표현하기 위해 이미 정해진 종류의 데이터들로, 모두 선택적으로 작성이 가능하며 사용할 것을 권장한다. 또한 Jwt를 간결하게 하기 위해 key는 모두 길이 3의 String이다.

여기서 subject로는 unique한 값을 사용하는데, 사용자 이메일을 주로 사용한다.

• iss: 토큰 발급자(issuer)
• sub: 토큰 제목(subject)
• aud: 토큰 대상자(audience)
• exp: 토큰 만료 시간(expiration), NumericDate 형식으로 되어 있어야 함 ex) 1480849147370
• nbf: 토큰 활성 날짜(not before), 이 날이 지나기 전의 토큰은 활성화되지 않음
• iat: 토큰 발급 시간(issued at), 토큰 발급 이후의 경과 시간을 알 수 있음
• jti: JWT 토큰 식별자(JWT ID), 중복 방지를 위해 사용하며, 일회용 토큰(Access Token) 등에 사용

 

2.2 공개 클레임(Public Claim)

공개 클레임은 사용자 정의 클레임으로, 공개용 정보를 위해 사용된다. 충돌 방지를 위해 URI 포맷을 이용하며, 예시는 아래와 같다.

{ 
    "https://mangkyu.tistory.com": true
}

 

2.3 비공개 클레임(Private Claim)

비공개 클레임은 사용자 정의 클레임으로, 서버와 클라이언트 사이에 임의로 지정한 정보를 저장한다. 아래의 예시와 같다.

{ 
    "token_type": access 
}

 

 

3. Signature(서명)

서명(Signature)은 토큰을 인코딩하거나 유효성 검증을 할 때 사용하는 고유한 암호화 코드이다. 

서명(Signature)은 위에서 만든 헤더(Header)와 페이로드(Payload)의 값을 각각 Base64로 인코딩하고, 인코딩한 값을 비밀 키를 이용해 헤더(Header)에서 정의한 알고리즘으로 해싱을 하고, 이 값을 다시 Base64로 인코딩하여 생성한다.

 

 

 

생성된 토큰은 HTTP 통신을 할 때 Authorization이라는 key의 value로 사용된다. 일반적으로 value에는 Bearer이 앞에 붙여진다.

{ 
    "Authorization": "Bearer {생성된 토큰 값}",
 }

 

 

[ Jwt 단점 및 고려사항 ]

• Self-contained : 토큰 자체에 정보를 담고 있으므로 양날의 검이 될 수 있다. 
• 토큰 길이 : 토큰의 페이로드(Payload)에 3종류의 클레임을 저장하기 때문에, 정보가 많아질수록 토큰의 길이가 늘어나 네트워크에 부하를 줄 수 있다. 
• Payload 인코딩 : 페이로드(Payload) 자체는 암호화 된 것이 아니라, Base64로 인코딩 된 것이다. 중간에 Payload를 탈취하여 디코딩하면 데이터를 볼 수 있으므로, Jwe로 암호화하거나 Payload에 중요 데이터를 넣지 않아야 한다. 
• Stateless : JWT는 상태를 저장하지 않기 때문에 한번 만들어지면 제어가 불가능하다. 즉, 토큰을 임의로 삭제하는 것이 불가능하므로 토큰 만료 시간을 꼭 넣어주어야 한다. 
• Store Token : 토큰은 클라이언트 측에서 관리해야 하기 때문에, 토큰을 저장해야 한다.

 

 

---

이제 Jwt를 이용한 인증 기능 구현을 위해 필요한 객체들을 만들어준다.

 

SecurityConfiguration

package com.example.finalproject.configuration;

import com.example.finalproject.jwt.AccessDeniedHandlerException;
import com.example.finalproject.jwt.AuthenticationEntryPointException;
import com.example.finalproject.jwt.TokenProvider;
import com.example.finalproject.service.UserDetailsServiceImpl;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.autoconfigure.condition.ConditionalOnWebApplication;
import org.springframework.boot.autoconfigure.security.ConditionalOnDefaultWebSecurity;
import org.springframework.boot.autoconfigure.security.SecurityProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.annotation.Order;
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.crypto.password.PasswordEncoder;
import org.springframework.security.web.SecurityFilterChain;
import org.springframework.web.cors.CorsUtils;

@Slf4j
@Configuration
@EnableWebSecurity
@RequiredArgsConstructor
@ConditionalOnDefaultWebSecurity
@ConditionalOnWebApplication(type = ConditionalOnWebApplication.Type.SERVLET)
public class SecurityConfiguration {

    @Value("${jwt.secret}")
    String SECRET_KEY;
    private final TokenProvider tokenProvider;
    private final UserDetailsServiceImpl userDetailsService;
    private final AuthenticationEntryPointException authenticationEntryPointException;
    private final AccessDeniedHandlerException accessDeniedHandlerException;
    private final CorsConfig corsConfig;

    @Bean
    public PasswordEncoder passwordEncoder() {
        log.info("회원관리 기능 절차(jwt) -> SecurityConfiguration - passwordEncoder 메소드");
        return new BCryptPasswordEncoder();
    }

    @Bean
    @Order(SecurityProperties.BASIC_AUTH_ORDER)
    public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
        log.info("회원관리 기능 절차(jwt) -> SecurityConfiguration - filterChain 메소드 (HttpSecurity : {})", http);

        http.cors();

        http.csrf().disable()

                .exceptionHandling()
                .authenticationEntryPoint(authenticationEntryPointException)
                .accessDeniedHandler(accessDeniedHandlerException)

                .and()
                .sessionManagement()
                .sessionCreationPolicy(SessionCreationPolicy.STATELESS)


                .and()
                .authorizeRequests()
                .requestMatchers(CorsUtils::isPreFlightRequest).permitAll() // 추가
                .antMatchers("/lier/signup",
                        "/lier/login",
                        "/lier/auth/**",
                        "/lier/chat/rooms",
                        "/lier/manager/**",
                        "/lier/room/test/**",
                        "/lier/room/**/exit"
                ).permitAll()

                .antMatchers("/api/comments/**").permitAll()
                .antMatchers("/v2/api-docs",
                        "/swagger-resources",
                        "/swagger-resources/**",
                        "/configuration/ui",
                        "/configuration/security",
                        "/swagger-ui.html",
                        "/webjars/**",
                        "/v3/api-docs/**",
                        "/js/**",
                        "/css/**",
                        "/swagger-ui/**").permitAll()
                .antMatchers("/ws-stomp").permitAll()
                .antMatchers("/ws-stomp/**").permitAll()
                .anyRequest().authenticated()

                .and()
                .addFilter(corsConfig.corsFilter())
                .apply(new JwtSecurityConfiguration(SECRET_KEY, tokenProvider, userDetailsService));

        return http.build();
    }


}

SecurityConfiguration은 보안을 위한 설정이나 접근을 허가하는 등의 보안에 관련된 설정을 종합적으로 설정하는 보안 객체이다.

 

JwtSecurityConfiguration

package com.example.finalproject.configuration;

import com.example.finalproject.jwt.JwtFilter;
import com.example.finalproject.jwt.TokenProvider;
import com.example.finalproject.service.UserDetailsServiceImpl;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.security.config.annotation.SecurityConfigurerAdapter;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.web.DefaultSecurityFilterChain;
import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;

@Slf4j
@RequiredArgsConstructor
public class JwtSecurityConfiguration
    extends SecurityConfigurerAdapter<DefaultSecurityFilterChain, HttpSecurity> {

  private final String SECRET_KEY;
  private final TokenProvider tokenProvider;
  private final UserDetailsServiceImpl userDetailsService;

  @Override
  public void configure(HttpSecurity httpSecurity) {
    log.info("회원관리 기능 절차(jwt) -> JwtSecurityConfiguration - configure 메소드 (HttpSecurity : {})", httpSecurity);
    JwtFilter customJwtFilter = new JwtFilter(SECRET_KEY, tokenProvider, userDetailsService);
    httpSecurity.addFilterBefore(customJwtFilter, UsernamePasswordAuthenticationFilter.class);
  }
}

• SecurityConfigurerAdapter<DefaultSecurityFilterChain, HttpSecurity> 인터페이스를 구현하는 구현체.
• 여기서 직접 만든 JwtFilter 를 Security Filter 앞에 추가한다.

 

 

JwtFilter

package com.example.finalproject.jwt;

import com.example.finalproject.controller.response.ResponseDto;
import com.example.finalproject.service.UserDetailsServiceImpl;
import com.fasterxml.jackson.databind.ObjectMapper;
import io.jsonwebtoken.Claims;
import io.jsonwebtoken.ExpiredJwtException;
import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.io.Decoders;
import io.jsonwebtoken.security.Keys;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.authority.SimpleGrantedAuthority;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.security.core.userdetails.UserDetails;
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.security.Key;
import java.time.Instant;
import java.util.Arrays;
import java.util.Collection;
import java.util.stream.Collectors;

@Slf4j
@RequiredArgsConstructor
public class JwtFilter extends OncePerRequestFilter {

    public static String AUTHORIZATION_HEADER = "Authorization";
    public static String BEARER_PREFIX = "Bearer ";
    public static String AUTHORITIES_KEY = "auth";
    private final String SECRET_KEY;
    private final TokenProvider tokenProvider;
    private final UserDetailsServiceImpl userDetailsService;

    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain)
            throws IOException, ServletException {

        byte[] keyBytes = Decoders.BASE64.decode(SECRET_KEY);
        Key key = Keys.hmacShaKeyFor(keyBytes);

        String jwt = resolveToken(request);

        if (StringUtils.hasText(jwt) && tokenProvider.validateToken(jwt)) {
            Claims claims;
            try {
                claims = Jwts.parserBuilder().setSigningKey(key).build().parseClaimsJws(jwt).getBody();
            } catch (ExpiredJwtException e) {
                claims = e.getClaims();
            }

            if (claims.getExpiration().toInstant().toEpochMilli() < Instant.now().toEpochMilli()) {
                response.setContentType("application/json;charset=UTF-8");
                response.getWriter().println(
                        new ObjectMapper().writeValueAsString(
                                ResponseDto.fail("BAD_REQUEST", "Token이 유효햐지 않습니다.")
                        )
                );
                response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
            }

            String subject = claims.getSubject();
            Collection<? extends GrantedAuthority> authorities =
                    Arrays.stream(claims.get(AUTHORITIES_KEY).toString().split(","))
                            .map(SimpleGrantedAuthority::new)
                            .collect(Collectors.toList());

            UserDetails principal = userDetailsService.loadUserByUsername(subject);

            Authentication authentication = new UsernamePasswordAuthenticationToken(principal, jwt, authorities);
            SecurityContextHolder.getContext().setAuthentication(authentication);

        }

        log.info("회원관리 기능 절차(jwt) -> JwtFilter - doFilterInternal 메소드 (request : {}, response : {}, filterChain : {}", request, response, filterChain);
        filterChain.doFilter(request, response);
    }

    private String resolveToken(HttpServletRequest request) {
        String bearerToken = request.getHeader(AUTHORIZATION_HEADER);
        if (StringUtils.hasText(bearerToken) && bearerToken.startsWith(BEARER_PREFIX)) {
            return bearerToken.substring(7);
        }

        log.info("회원관리 기능 절차(jwt) -> JwtFilter - resolveToken 메소드 (bearerToken : {})", bearerToken);
        return null;
    }

}

• OncePerRequestFilter 인터페이스를 구현하기 때문에 요청 받을 때 단 한번만 실행된다.
• doFilterInternal
  • 실제 필터링 로직을 수행하는 곳.
  • Request Header에서 Access Token을 꺼내고(resolveToken) 여러가지 검사 후 유저 정보를 꺼내서 SecurityContext 에 저장한다.
  • 가입/로그인/재발급을 제외한 모든 Request 요청은 이 필터를 거치기 때문에 토큰 정보가 없거나 유효하지 않으면 정상적으로 수행되지 않는다. (예 : 게시글 작성, 게임방 생성, 게임방 입장 등)
  • 그리고 요청이 정상적으로 Controller 까지 도착했다면 SecurityContext 에 Member ID 가 존재한다는 것이 보장된다.
  • 대신 직접 DB 를 조회한 것이 아니라 Access Token 에 있는 Member ID 를 꺼낸 거라서, 탈퇴로 인해 Member ID 가 DB 에 없는 경우 등 예외 상황은 Service 단에서 고려해야 한다.

 

AccessDeniedHandlerException

package com.example.finalproject.jwt;

import com.example.finalproject.controller.response.ResponseDto;
import com.fasterxml.jackson.databind.ObjectMapper;
import lombok.extern.slf4j.Slf4j;
import org.springframework.security.access.AccessDeniedException;
import org.springframework.security.web.access.AccessDeniedHandler;
import org.springframework.stereotype.Component;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

@Slf4j
@Component
public class AccessDeniedHandlerException implements AccessDeniedHandler {

    @Override
    public void handle(HttpServletRequest request, HttpServletResponse response,
                       AccessDeniedException accessDeniedException) throws IOException {

        response.setContentType("application/json;charset=UTF-8");
        response.getWriter().println(
                new ObjectMapper().writeValueAsString(
                        ResponseDto.fail("BAD_REQUEST", "로그인이 필요합니다.")
                )
        );

        response.setStatus(HttpServletResponse.SC_FORBIDDEN);
        log.info("회원관리 기능 절차(jwt) -> AccessDeniedHandlerException - handle 메소드 (request : {}, response : {}, accessDeniedException : {})", request, response, accessDeniedException.getMessage());
    }
}

AccessDeniedHandlerException은 잘못된 접근이 발생하였을 때 에러처리를 진행해준다.

 

 

AuthenticationEntryPointException

package com.example.finalproject.jwt;

import com.example.finalproject.controller.response.ResponseDto;
import com.fasterxml.jackson.databind.ObjectMapper;
import lombok.extern.slf4j.Slf4j;
import org.springframework.security.core.AuthenticationException;
import org.springframework.security.web.AuthenticationEntryPoint;
import org.springframework.stereotype.Component;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

@Slf4j
@Component
public class AuthenticationEntryPointException implements
        AuthenticationEntryPoint {

  @Override
  public void commence(HttpServletRequest request, HttpServletResponse response,
                       AuthenticationException authException) throws IOException {
    response.setContentType("application/json;charset=UTF-8");
    response.getWriter().println(
            new ObjectMapper().writeValueAsString(
                    ResponseDto.fail("BAD_REQUEST", "로그인이 필요합니다.")
            )
    );
    response.setStatus(HttpServletResponse.SC_UNAUTHORIZED);
    log.info("회원관리 기능 절차(jwt) -> AuthenticationEntryPointException - commence 메소드 (request : {}, response : {}, authException : {})", request, response, authException.getMessage());
  }
}

AuthenticationEntryPointException은 인가받지 못한 권한일 때 에러 처리를 진행해준다.

 

 

TokenProvider

package com.example.finalproject.jwt;

import com.example.finalproject.controller.request.TokenDto;
import com.example.finalproject.controller.response.ResponseDto;
import com.example.finalproject.domain.Member;
import com.example.finalproject.domain.RefreshToken;
import com.example.finalproject.domain.UserDetailsImpl;
import com.example.finalproject.exception.PrivateResponseBody;
import com.example.finalproject.exception.StatusCode;
import com.example.finalproject.repository.RefreshTokenRepository;
import com.example.finalproject.shared.Authority;

import io.jsonwebtoken.*;
import io.jsonwebtoken.io.Decoders;
import io.jsonwebtoken.security.Keys;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.security.authentication.AnonymousAuthenticationToken;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Transactional;

import java.security.Key;
import java.util.Date;
import java.util.Optional;

@Slf4j
@Component
public class TokenProvider {

  private static final String AUTHORITIES_KEY = "auth";
  private static final String BEARER_PREFIX = "Bearer ";
  private static final long ACCESS_TOKEN_EXPIRE_TIME = 1000 * 60 * 60 * 24 * 7;       //7일
  private static final long REFRESH_TOKEN_EXPRIRE_TIME = 1000 * 60 * 60 * 24 * 7;     //7일

  private final Key key;

  private final RefreshTokenRepository refreshTokenRepository;

  public TokenProvider(@Value("${jwt.secret}") String secretKey,
      RefreshTokenRepository refreshTokenRepository) {
    this.refreshTokenRepository = refreshTokenRepository;
    byte[] keyBytes = Decoders.BASE64.decode(secretKey);
    this.key = Keys.hmacShaKeyFor(keyBytes);
  }

  public TokenDto generateTokenDto(Member member) {
    long now = (new Date().getTime());

    Date accessTokenExpiresIn = new Date(now + ACCESS_TOKEN_EXPIRE_TIME);
    String accessToken = Jwts.builder()
        .setSubject(member.getEmail())
        .claim(AUTHORITIES_KEY, Authority.ROLE_MEMBER.toString())
        .setExpiration(accessTokenExpiresIn)
        .signWith(key, SignatureAlgorithm.HS256)
        .compact();

    String refreshToken = Jwts.builder()
        .setExpiration(new Date(now + REFRESH_TOKEN_EXPRIRE_TIME))
        .signWith(key, SignatureAlgorithm.HS256)
        .compact();

    RefreshToken refreshTokenObject = RefreshToken.builder()
        .id(member.getMemberId())
        .member(member)
        .value(refreshToken)
        .build();

    refreshTokenRepository.save(refreshTokenObject);

    return TokenDto.builder()
        .grantType(BEARER_PREFIX)
        .accessToken(accessToken)
        .accessTokenExpiresIn(accessTokenExpiresIn.getTime())
        .refreshToken(refreshToken)
        .build();

  }

  public Member getMemberFromAuthentication() {
    Authentication authentication = SecurityContextHolder.getContext().getAuthentication();
    if (authentication == null || AnonymousAuthenticationToken.class.
        isAssignableFrom(authentication.getClass())) {
      return null;
    }
    return ((UserDetailsImpl) authentication.getPrincipal()).getMember();
  }

  public boolean validateToken(String token) {
    try {
      Jwts.parserBuilder().setSigningKey(key).build().parseClaimsJws(token);
      return true;
    } catch (SecurityException | MalformedJwtException e) {
      log.info("Invalid JWT signature, 유효하지 않는 JWT 서명 입니다.");
    } catch (ExpiredJwtException e) {
      log.info("Expired JWT token, 만료된 JWT token 입니다.");
    } catch (UnsupportedJwtException e) {
      log.info("Unsupported JWT token, 지원되지 않는 JWT 토큰 입니다.");
    } catch (IllegalArgumentException e) {
      log.info("JWT claims is empty, 잘못된 JWT 토큰 입니다.");
    }
    return false;
  }

  @Transactional(readOnly = true)
  public RefreshToken isPresentRefreshToken(Member member) {
    Optional<RefreshToken> optionalRefreshToken = refreshTokenRepository.findByMember(member);
    return optionalRefreshToken.orElse(null);
  }

  @Transactional
  public ResponseEntity<?> deleteRefreshToken(Member member) {

    RefreshToken refreshToken = isPresentRefreshToken(member);

    if (null == refreshToken) {
      return new ResponseEntity<>(new PrivateResponseBody
              (StatusCode.LOGIN_WRONG_FORM_JWT_TOKEN,null), HttpStatus.NOT_FOUND);
    }

    refreshTokenRepository.delete(refreshToken);

    return new ResponseEntity<>(new PrivateResponseBody
            (StatusCode.OK,"로그아웃"),HttpStatus.OK);
  }
}

TokenProvider은 인증을 통과한 후에 발급되는 액세스 토큰 및 리프레시 토큰에 대한 작업 처리를 진행하는 객체이다.

• JWT 토큰에 관련된 암호화, 복호화, 검증 로직은 다 이곳에서 이루어진다.
• 생성자
  • application.properties 에 정의해놓은 jwt.secret 값을 가져와서 JWT 를 만들 때 사용하는 암호화 키값을 생성한다.
• generateTokenDto
  • 유저 정보를 넘겨받아서 Access Token 과 Refresh Token 을 생성한다.
  • 넘겨받은 유저 정보의 member.getEmail() 메소드가 유저의 이메일을 가져온다.
  • 나는 email로 Member ID 를 저장했기 때문에 해당 값이 설정될 것이다.
  • Access Token 에는 유저와 권한 정보를 담고 Refresh Token 에는 아무 정보도 담지 않는다.
• validateToken
  • 토큰 정보를 검증한다.
  • Jwts 모듈이 알아서 Exception 을 던진다.

 

UserDetailsServiceImpl

package com.example.finalproject.service;

import com.example.finalproject.domain.Member;
import com.example.finalproject.domain.UserDetailsImpl;
import com.example.finalproject.repository.MemberRepository;
import lombok.RequiredArgsConstructor;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.core.userdetails.UsernameNotFoundException;
import org.springframework.stereotype.Service;

@Service
@RequiredArgsConstructor
public class UserDetailsServiceImpl implements UserDetailsService{
  private final MemberRepository memberRepository;

  @Override
  public UserDetails loadUserByUsername(String email) throws UsernameNotFoundException {
    Member member = memberRepository.findByEmail(email)
            .orElseThrow(() -> new UsernameNotFoundException("Can't find " + email));

    return new UserDetailsImpl(member);
  }
}

 

 

UserDetailsImpl

package com.example.finalproject.domain;

import com.example.finalproject.shared.Authority;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.authority.SimpleGrantedAuthority;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.oauth2.core.user.OAuth2User;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Map;

@Data
@NoArgsConstructor
public class UserDetailsImpl implements UserDetails,OAuth2User {

  private Member member;
  private Map<String, Object> attributes;

  public UserDetailsImpl(Member member){
    this.member = member;
  }

  public UserDetailsImpl(Member member, Map<String, Object> attributes){
    this.member = member;
    this.attributes = attributes;
  }

  @Override
  public Collection<? extends GrantedAuthority> getAuthorities() {
    SimpleGrantedAuthority authority = new SimpleGrantedAuthority(Authority.ROLE_MEMBER.toString());
    Collection<GrantedAuthority> authorities = new ArrayList<>();
    authorities.add(authority);
    return authorities;
  }

  @Override
  public String getPassword() {
    return member.getPassword();
  }

  @Override
  public String getUsername() {
    return member.getEmail();
  }

  @Override
  public boolean isAccountNonExpired() {
    return true;
  }

  @Override
  public boolean isAccountNonLocked() {
    return true;
  }

  @Override
  public boolean isCredentialsNonExpired() {
    return true;
  }

  @Override
  public boolean isEnabled() {
    return true;
  }

  @Override
  public Map<String, Object> getAttributes(){
    return attributes;
  }

  @Override
  public String getName(){
    return null;
  }

}

 

UserDetailsServiceImpl과 UserDetailsImpl은 유저의 정보를 캐시처럼 저장해놓고 사용하는 용도의 객체이다.

 

 

CorsConfig

package com.example.finalproject.configuration;

import lombok.extern.slf4j.Slf4j;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.cors.CorsConfiguration;
import org.springframework.web.cors.UrlBasedCorsConfigurationSource;
import org.springframework.web.filter.CorsFilter;

@Slf4j
@Configuration
public class CorsConfig {
    @Bean
    public CorsFilter corsFilter(){
        UrlBasedCorsConfigurationSource source =new UrlBasedCorsConfigurationSource();
        CorsConfiguration config = new CorsConfiguration();
        config.setAllowCredentials(true);// 내서버가 응답을 할 떄 json을 자바스크립트에서 처리할 수 있게 할지를 설정하는 것
        config.addAllowedOrigin("https://{도메인url}/");
        config.addAllowedOrigin("https://{도메인url}/5000");
        config.addAllowedOrigin("https://localhost:5000");
        config.addAllowedOrigin("https://localhost:8443");
        config.addAllowedOrigin("https://{두번째 도메인url}/");
        config.addAllowedOrigin("http://localhost:3000");
        config.addAllowedOrigin("https://{메인 도메인url}/");
        config.addAllowedHeader("*");//모든 header의 응답을 허용하겠다.
        config.addAllowedMethod("*");//모든 post,get,put,delete,patch 요청을 허용하겠다.
        config.addExposedHeader("*");
        source.registerCorsConfiguration("/lier/**",config);

        log.info("회원관리 기능 절차(jwt) -> CorsConfig - corsFilter 메소드");

        return new CorsFilter(source);
    }
}

프론트 분들과 협업을 진행하게 되면 백엔드 쪽에서 구현한 서버 자원을 프론트에 넘겨드려야 하는데 이 과정에서 다른 서버가 사용하고자 하는 서버의 자원에 대한 접근 권한이 없기 때문에 에러가 나게 된다.

이를 해결하고자 Cors 설정을 통해 허가를 해주어야 한다.