[Spring Security] 3. Spring Security 적용하기 (JWT, Access Token, Refresh Token)

---

들어가며

---

지난 게시글에서 스프링 시큐리티를 이용한 로그인 구현 시 Session을 사용하는 방법을 알아보았다. 스프링 시큐리티는 기본적으로 Session을 사용하는 것이 기본이지만 JWT를 이용하여 로그인을 구현할 수도 있다. 때문에, JWT를 이용한 로그인을 만들어보았다.

 

해당 글을 작성하며, 지난 게시글에서 설명한 내용중 겹치는 내용의 일부분은 생략했다. 때문에 설명이 필요한 부분이 있다면 이전 게시글을 참고하면 된다.

또한, Session을 이용한 스프링 시큐리티 로그인은 해당 글을 참고하면 된다.

링크 : https://jangjjolkit.tistory.com/25

[Spring Security] 2. Spring Security 적용하기 (Session)

 

 

1. JWT란?

---

개발에 들어가기 전, JWT에 대해서 알아야 한다.

 

JWT(Json Web Token)란 Json 포맷을 이용하여 사용자에 대한 속성을 저장하는 Claim 기반의 Web Token이다. JWT는 토큰 자체를 정보로 사용하는 Self-Contained 방식으로 정보를 안전하게 전달한다. 주로 회원 인증이나 정보 전달에 사용되는 JWT는 아래의 로직을 따라서 처리된다.

 

 

2. JWT 구조

---

JWT는 Header, Payload, Signature의 3 부분으로 이루어지며, Json 형태인 각 부분은 Base64Url로 인코딩 되어 표현된다. 또한 각각의 부분을 이어 주기 위해 . 구분자를 사용하여 구분한다. 추가로 Base64Url는 암호화된 문자열이 아니고, 같은 문자열에 대해 항상 같은 인코딩 문자열을 반환한다.

 

1. Header (헤더)

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

{
	"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://jangjjolkit.tistory.com": true
}

 

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

{
	"token_type": access
}

3. Signature (서명)

서명(Signature)은 토큰을 인코딩하거나 유효성 검증을 할 때 사용하는 고유한 암호화 코드이다. 서명(Signature)은 위에서 만든 헤더(Header)와 페이로드(Payload)의 값을 각각 BASE64Url로 인코딩하고, 인코딩한 값을 비밀 키를 이용해 헤더(Header)에서 정의한 알고리즘으로 해싱을 하고, 이 값을 다시 BASE64Url로 인코딩하여 생성한다.

[JWT 토큰 예시]

 

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

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

[JWT 장점]

• 서버가 다수 존재하는 환경에서 유용하다. 세션을 사용하면 모든 서버에서 세션 내용을 공유해야 하기 때문
• 매 요청시마다 DB 조회를 하지 않고 토큰 자체만으로 사용자의 정보와 권한을 알 수 있기에 병목현상 방지

[JWT 단점 및 고려사항]

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

 

 

3. Refresh Token

---

위에서 설명한 것 처럼, JWT는 토큰 자체에 정보를 담고있어 보안이 매우 취약하다. 만약 JWT 토큰을 탈취당하게 되면 해당 사용자의 권한과 정보를 모두 빼앗기게 된다.

 

이를 보완하기 위해서 Refresh Token의 개념이 사용되었다.

• Access Token의 유효기간은 매우 짧게
• Refresh Token의 유효기간은 길게

해주는 것이 포인트이다.

 

즉,

• Access Token을 통해서만 자원에 접근이 가능, But 유효기간이 매우 짧다(탈취를 당해도 이미 사용할 수 없는 상태)
• Refresh Token은 유효기간이 길기에 탈취당할 수도 있지만 Refresh Token은 오직 Access 토큰을 재발급하는 용도(Refresh Token 자체로는 별 쓸모가 없다.)

JWT 인증 과정

더 간단한 흐름도로 보면 다음과 같다.

JWT 인증 과정 흐름도

Refresh Token을 사용하여 다음과 같은 이득을 얻을 수 있다.

• Access Token의 유효기간을 짧게 하여 탈취 방지
  • Access Token이 탈취당하더라도 유효기간이 짧아 사용할 수 있는 기간이 줄어들어 탈취 방지 효과가 있음
• Access 토큰의 유효기간에 짧음에도 불구하고 Refresh Token이 만료될때까지 추가적인 로그인을 하지 않아도 됨
  
  • 마치 세션이 유지되는 것 같은 효과가 있음

---

JWT의 개념이 학습되었다면 이제 스프링 시큐리티와 JWT를 이용한 로그인을 개발할 차례이다.

이번 게시글에서는 Gradle을 이용한 개발 방법을 설명하려고 한다.

 

 

4. Dependency 추가

---

 

<Gradle>

implementation 'org.springframework.boot:spring-boot-starter-security'
testImplementation 'org.springframework.security:spring-security-test'
implementation group: 'io.jsonwebtoken', name: 'jjwt', version: '0.9.1'
implementation group: 'javax.xml.bind', name: 'jaxb-api', version: '2.3.1'

 

 

5. Java Configuration

---

WebSecurityConfigurerAdapter를 상속받은 config 클래스에 @EnableWebSecurity 어노테이션을 달면 SpringSecurityFilterChain이 자동으로 포함된다.

@Configuration
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {
}

 

그 후에 configure 메소드를 오버라이딩하여 접근 권한을 설정한다.

@Configuration
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {
	// 인증되지 않은 사용자 접근에 대한 handler
	@Autowired private JwtAuthenticationEntryPoint jwtAuthenticationEntryPoint;
	// JWT 요청 처리 필터
	@Autowired private JwtRequestFilter jwtRequestFilter;
	
	/*
	* 스프링 시큐리티 룰을 무시할 URL 규칙 설정
	* 정적 자원에 대해서는 Security 설정을 적용하지 않음
	*/ 
	@Override
	public void configure(WebSecurity web) throws Exception {
		web.ignoring()
			.antMatchers("/resources/**")
			.antMatchers("/css/**")
			.antMatchers("/vendor/**")
			.antMatchers("/js/**")
			.antMatchers("/favicon*/**")
			.antMatchers("/img/**");
	}
	
	// 스프링 시큐리티 규칙
	@Override
	protected void configure(HttpSecurity http) throws Exception {
		http.csrf().disable() // csrf 보안 설정 비활성화
			.antMatcher("/**").authorizeRequests() // 보호된 리소스 URI에 접근할 수 있는 권한 설정

			.antMatchers("/index").permitAll() // 전체 접근 허용
			.antMatchers("/main").authenticated() // 인증된 사용자만 접근 허용
			.antMatchers("/regist").annonymous() // 인증되지 않은 사용자만 접근 허용
			.antMatchers("/mypage").hasRole("ADMIN") // ROLE_ADMIN 권한을 가진 사용자만 접근 허용
			.antMatchers("/check").hasAnyRole("ADMIN", "USER") // ROLE_ADMIN 혹은 ROLE_USER 권한을 가진 사용자만 접근 허용
			
			// 그 외 항목 전부 인증 적용
			.anyRequest()
			.authenticated()
		
		// exception 처리
		.and()
		.exceptionHandling()
			.authenticationEntryPoint(webAuthenticationEntryPoint) // 인증되지 않은 사용자 접근 시
		
		// Spring Security에서 session을 생성하거나 사용하지 않도록 설정
		.and()
		.sessionManagement()
			.sessionCreationPolicy(SessionCreationPolicy.STATELESS)
		
		// JWT filter 적용
		.and()
		.addFilterBefore(jwtRequestFilter, UsernamePasswordAuthenticationFilter.class);
	}
}

 

---

2023-08-07 추가사항

스프링 시큐리티 6.1부터 설정 방법이 변경되었다. 토이프로젝트를 진행하다가 발견했다.

변경 예시는 아래 더보기를 참고하면 된다.

@Configuration
@EnableWebSecurity
@RequiredArgsConstructor
public class SecurityConfig {

    private final JwtAuthenticationEntryPoint jwtAuthenticationEntryPoint;

    private final JwtRequestFilter jwtRequestFilter;

    @Bean
    public BCryptPasswordEncoder bCryptPasswordEncoder() {
        return new BCryptPasswordEncoder();
    }

    @Bean
    MvcRequestMatcher.Builder mvc(HandlerMappingIntrospector introspector) {
        return new MvcRequestMatcher.Builder(introspector);
    }

    @Bean
    public SecurityFilterChain config(HttpSecurity http, MvcRequestMatcher.Builder mvc) throws Exception {
        MvcRequestMatcher[] PERMIT_ALL_WHITE_LIST = {
                mvc.pattern("/store"),
                mvc.pattern("/manage/store/admin"),
                mvc.pattern("/manage/login")
        };

        http.csrf(AbstractHttpConfigurer::disable);

        http.headers((headers) ->
                headers.frameOptions(HeadersConfigurer.FrameOptionsConfig::disable));

        // http request 인증 설정
        http.authorizeHttpRequests(authorize ->
                authorize.requestMatchers(PERMIT_ALL_WHITE_LIST).permitAll()
                        .anyRequest().authenticated()
        );

        // 인증 실패 시 exception handler 설정
        http.exceptionHandling(httpSecurityExceptionHandlingConfigurer -> httpSecurityExceptionHandlingConfigurer.authenticationEntryPoint(jwtAuthenticationEntryPoint));

        // Spring Security에서 session을 생성하거나 사용하지 않도록 설정
        http.sessionManagement(httpSecuritySessionManagementConfigurer -> httpSecuritySessionManagementConfigurer.sessionCreationPolicy(SessionCreationPolicy.STATELESS));

        // jwt Filter 적용
        http.addFilterBefore(jwtRequestFilter, UsernamePasswordAuthenticationFilter.class);

        return http.build();
    }

}

---

 

JWT를 사용하는 경우 session을 사용하지 않기 때문에 스프링 시큐리티에서 session을 생성하거나 사용하지 않도록 설정한다.

 

다음은 세션 생성 정책 열거체인 SessionCreationPolicy의 항목들이다.

 

• ALWAYS (Default)
  • 스프링 시큐리티가 HttpSession을 항상 생성하고 사용
• NEVER
  • 스프링 시큐리티가 HttpSession을 생성하지 않으나, 이미 존재하는 HttpSession에 대해서는 사용
• IF_REQUIRED
  • 스프링 시큐리티가 필요한 경우에만 HttpSession을 생성
• STATELESS
  • 스프링 시큐리티가 HttpSession을 생성하지 않고, SecurityContext를 획득하는 데 사용하지 않음

 

 

6. JWT Request Filter 구현

---

클라이언트 요청 시 JWT를 검증하는 Filter를 구현한다. 요청당 한 번의 filter 수행을 위해 OncePerRequestFilter를 상속받는다.

 

@Component
public class JwtRequestFilter extends OncePerRequestFilter {
	private final Logger log = LoggerFactory.getLogger(this.getClass());
	
	// 실제 JWT 검증을 실행하는 Provider
	@Autowired private JwtTokenProvider jwtTokenProvider;
	
	// 인증에서 제외할 url
	private static final List<String> EXCLUDE_URL =
		Collections.unmodifiableList(
			Arrays.asList(
				"/static/**",
				"/favicon.ico",
				"/admin",
				"/admin/authentication",
				"/admin/refresh",
				"/admin/join",
				"/admin/join/**",
				"/admin/loginView",
				"/admin/login"
			));
	
	@Override
	protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain)
			throws ServletException, IOException {
		// jwt local storage 사용 시 해당 코드를 사용하여 header에서 토큰을 받아오도록 함
		// final String token = request.getHeader("Authorization");
		
		// jwt cookie 사용 시 해당 코드를 사용하여 쿠키에서 토큰을 받아오도록 함
		String token = Arrays.stream(request.getCookies())
				.filter(c -> c.getName().equals("jdhToken"))
				.findFirst() .map(Cookie::getValue)
				.orElse(null);
		
		String adminId = null;
		String jwtToken = null;
		
		// Bearer token인 경우 JWT 토큰 유효성 검사 진행
		if (token != null && token.startsWith("Bearer ")) {
			jwtToken = token.substring(7);
			try {
				adminId = jwtTokenProvider.getUsernameFromToken(jwtToken);
			} catch (SignatureException e) {
				log.error("Invalid JWT signature: {}", e.getMessage());
			} catch (MalformedJwtException e) {
				log.error("Invalid JWT token: {}", e.getMessage());
			} catch (ExpiredJwtException e) {
				log.error("JWT token is expired: {}", e.getMessage());
			} catch (UnsupportedJwtException e) {
				log.error("JWT token is unsupported: {}", e.getMessage());
			} catch (IllegalArgumentException e) {
				log.error("JWT claims string is empty: {}", e.getMessage());
			}
		} else {
			logger.warn("JWT Token does not begin with Bearer String");
		}
		
		// token 검증이 되고 인증 정보가 존재하지 않는 경우 spring security 인증 정보 저장
		if(adminId != null && SecurityContextHolder.getContext().getAuthentication() == null) {
			AdminDTO adminDTO = new AdminDTO();
			// DB에서 관련 정보 조회
			// ...
			
			if(jwtTokenProvider.validateToken(jwtToken, adminDTO)) {
				UsernamePasswordAuthenticationToken authenticationToken =
						new UsernamePasswordAuthenticationToken(adminDTO, null ,adminDTO.getAuthorities());
				
				authenticationToken.setDetails(new WebAuthenticationDetailsSource().buildDetails(request));
				SecurityContextHolder.getContext().setAuthentication(authenticationToken);
			}
		}
		
		// accessToken 인증이 되었다면 refreshToken 재발급이 필요한 경우 재발급
		try {
			if(adminId != null) {
				jwtTokenProvider.reGenerateRefreshToken(adminId);
			}
		}catch (Exception e) {
			log.error("[JwtRequestFilter] refreshToken 재발급 체크 중 문제 발생 : {}", e.getMessage());
		}
		
		filterChain.doFilter(request,response);
	}
	
	// Filter에서 제외할 URL 설정
	@Override
	protected boolean shouldNotFilter(HttpServletRequest request) throws ServletException {
		return EXCLUDE_URL.stream().anyMatch(exclude -> exclude.equalsIgnoreCase(request.getServletPath()));
	}
}

 

JWT 토큰 유효성 검사를 진행하고 검사에 통과한 경우 Refresh Token 재발급 여부를 체크한다. 재발급이 필요한 경우 Refresh Token을 재발급하도록 했다. Access Token은 클라이언트가 직접 관리해야 하지만, Refresh Token은 서버가 직접 관리하는 것이 좋다. 필자는 Access Token은 쿠키 혹인 local storage에, Refresh Token은 DB에 저장하여 관리하도록 했다.

 

 

7. JWT Token Provider 구현

---

 

이번 게시글에서는 secret 변수를 이용하여 JWT 토큰 검증을 진행했다. 실제 운영환경에서는 해당 기능 대신 사용자 정보를 이용하는 등 별도의 기능을 사용해야 할 것 같다.

 

@Component
public class JwtTokenProvider {
	private final Logger log = LoggerFactory.getLogger(this.getClass());
	
	private static String secret = "jangdaehyeok";
	
	// 1시간 단위
	public static final long JWT_TOKEN_VALIDITY = 1000 * 60 * 60;
	
	// token으로 사용자 id 조회
	public String getUsernameFromToken(String token) {
		return getClaimFromToken(token, Claims::getId);
	}
	
	// token으로 사용자 속성정보 조회
	public <T> T getClaimFromToken(String token, Function<Claims, T> claimsResolver) {
		final Claims claims = getAllClaimsFromToken(token);
		return claimsResolver.apply(claims);
	}
	
	// 모든 token에 대한 사용자 속성정보 조회
	private Claims getAllClaimsFromToken(String token) {
		return Jwts.parser().setSigningKey(secret).parseClaimsJws(token).getBody();
	}
	
	// 토근 만료 여부 체크
	/*
	private Boolean isTokenExpired(String token) {
		final Date expiration = getExpirationDateFromToken(token);
		return expiration.before(new Date());
	}
	*/
	
	// 토큰 만료일자 조회
	public Date getExpirationDateFromToken(String token) {
		return getClaimFromToken(token, Claims::getExpiration);
	}
	
	// id를 입력받아 accessToken 생성
	public String generateAccessToken(String id) {
		return generateAccessToken(id, new HashMap<>());
	}
	
	// id, 속성정보를 이용해 accessToken 생성
	public String generateAccessToken(String id, Map<String, Object> claims) {
		return doGenerateAccessToken(id, claims);
	}
	
	// JWT accessToken 생성
	private String doGenerateAccessToken(String id, Map<String, Object> claims) {
		String accessToken = Jwts.builder()
				.setClaims(claims)
				.setId(id)
				.setIssuedAt(new Date(System.currentTimeMillis()))
				.setExpiration(new Date(System.currentTimeMillis() + JWT_TOKEN_VALIDITY * 1))// 1시간
				.signWith(SignatureAlgorithm.HS512, secret)
				.compact();
		
		return accessToken;
	}
	
	// id를 입력받아 accessToken 생성
	public String generateRefreshToken(String id) {
		return doGenerateRefreshToken(id);
	}
	
	// JWT accessToken 생성
	private String doGenerateRefreshToken(String id) {
		String refreshToken = Jwts.builder()
				.setId(id)
				.setExpiration(new Date(System.currentTimeMillis() + JWT_TOKEN_VALIDITY * 5)) // 5시간
				.setIssuedAt(new Date(System.currentTimeMillis()))
				.signWith(SignatureAlgorithm.HS512, secret)
				.compact();
		
		return refreshToken;
	}
	
	// id를 입력받아 accessToken, refreshToken 생성
	public Map<String, String> generateTokenSet(String id) {
		return generateTokenSet(id, new HashMap<>());
	}
	
	// id, 속성정보를 이용해 accessToken, refreshToken 생성
	public Map<String, String> generateTokenSet(String id, Map<String, Object> claims) {
		return doGenerateTokenSet(id, claims);
	}
	
	// JWT accessToken, refreshToken 생성
	private Map<String, String> doGenerateTokenSet(String id, Map<String, Object> claims) {
		Map<String, String> tokens = new HashMap<String, String>();
		
		String accessToken = Jwts.builder()
				.setClaims(claims)
				.setId(id)
				.setIssuedAt(new Date(System.currentTimeMillis()))
				.setExpiration(new Date(System.currentTimeMillis() + JWT_TOKEN_VALIDITY * 1))// 1시간
				.signWith(SignatureAlgorithm.HS512, secret)
				.compact();
		
		String refreshToken = Jwts.builder()
				.setId(id)
				.setExpiration(new Date(System.currentTimeMillis() + JWT_TOKEN_VALIDITY * 5)) // 5시간
				.setIssuedAt(new Date(System.currentTimeMillis()))
				.signWith(SignatureAlgorithm.HS512, secret)
				.compact();
		
		tokens.put("accessToken", accessToken);
		tokens.put("refreshToken", refreshToken);
		return tokens;
	}
	
	// JWT refreshToken 만료체크 후 재발급
	public Boolean reGenerateRefreshToken(String id) throws Exception {
		log.info("[reGenerateRefreshToken] refreshToken 재발급 요청");
		// 관리자 정보 조회
		AdminDTO aDTO = new AdminDTO();
		// DB에서 정보 조회
		// ...
		
		// DB에서 refreshToken 정보 조회
		RefreshTokenDTO rDTO = new RefreshTokenDTO();
		// ... DB 조회 부분
		
		// refreshToken 정보가 존재하지 않는 경우
		if(rDTO == null) {
			log.info("[reGenerateRefreshToken] refreshToken 정보가 존재하지 않습니다.");
			return false;
		}
		
		// refreshToken 만료 여부 체크
		try {
			String refreshToken = rDTO.getRefreshToken().substring(7);
			Jwts.parser().setSigningKey(secret).parseClaimsJws(refreshToken);
			log.info("[reGenerateRefreshToken] refreshToken이 만료되지 않았습니다.");
			return true;
		}
		// refreshToken이 만료된 경우 재발급
		catch(ExpiredJwtException e) {
			rDTO.setRefreshToken("Bearer " + generateRefreshToken(id));
			// ... DB에서 refreshToken 정보 수정
			log.info("[reGenerateRefreshToken] refreshToken 재발급 완료 : {}", "Bearer " + generateRefreshToken(id));
			return true;
		}
		// 그 외 예외처리
		catch(Exception e) {
			log.error("[reGenerateRefreshToken] refreshToken 재발급 중 문제 발생 : {}", e.getMessage());
			return false;
		}
	}
	
	// 토근 검증
	public Boolean validateToken(String token, AdminDTO adminDTO) {
		try {
			Jwts.parser().setSigningKey(secret).parseClaimsJws(token);
			return true;
		} catch (SignatureException e) {
			log.error("Invalid JWT signature: {}", e.getMessage());
		} catch (MalformedJwtException e) {
			log.error("Invalid JWT token: {}", e.getMessage());
		} catch (ExpiredJwtException e) {
			log.error("JWT token is expired: {}", e.getMessage());
		} catch (UnsupportedJwtException e) {
			log.error("JWT token is unsupported: {}", e.getMessage());
		} catch (IllegalArgumentException e) {
			log.error("JWT claims string is empty: {}", e.getMessage());
		}
		
		return false;
	}
}​

 

 

8. AuthenticationEntryPoint 구현

---

인증이 되지 않은 사용자가 요청을 한 경우 동작하기 위해 AuthenticationEntryPoint를 상속받는 핸들러를 구현한다.

에러코드를 반환하는 역할을 한다.

 

@Component
public class JwtAuthenticationEntryPoint implements AuthenticationEntryPoint {
	@Override
	public void commence(HttpServletRequest request, HttpServletResponse response,
			AuthenticationException authException) throws IOException, ServletException {
		response.sendError(HttpServletResponse.SC_UNAUTHORIZED, "UnAuthorized");
	}
}

 

 

9. JWT Controller 구현

---

JWT 관련 Controller를 구현한다. 해당 컨트롤러에서는 로그인, 로그인 성공 시 Access Token 발급, Access Token 재발급 요청 등을 담당한다. 필자는 클라이언트측에서 직접 Access Token 재발급을 요청하도록 개발했지만, 상황에 따라 서버측에서 자동으로 Access Token을 자동으로 재발급해주는 방법도 좋을 듯 하다.

 

@RestController
public class TestAdminJwtController {
	private final Logger log = LoggerFactory.getLogger(this.getClass());
	
	@Autowired JwtTokenProvider jwtTokenUtil;
	
	// JWT 토큰 발급
	/* localStorage 사용 시 해당 코드를 사용
	@PostMapping(value="admin/authentication")
	public ResponseEntity<AdminDTO> TestAdminAdminGet(@RequestBody Map<String, Object> input, HttpServletRequest req, HttpServletResponse rep) throws Exception{
		AdminDTO aDTO = // ... 로그인 관련 로직 실행
		
		// JWT 발급
		final String token = jwtTokenUtil.generateToken(aDTO.getAdmId());
		aDTO.setToken(token);
		
		// 비밀번호 정보 제거
		aDTO.setAdmPw("");
		
		return ResponseEntity.ok(aDTO);
	}
	*/
	
	// JWT 토큰 발급(쿠키 사용 시)
	@PostMapping(value="admin/authentication")
	public Map<String, Object> testJwtTokenGet(@RequestBody Map<String, Object> input, HttpServletRequest req, HttpServletResponse rep) throws Exception{
		Map<String, Object> returnMap = new HashMap<String, Object>();
		AdminDTO aDTO = // ... 로그인 관련 로직 실행
		
		// 권한 map 저장
		Map<String, Object> rules = new HashMap<String, Object>();
		rules.put("rules", /* ... 권한 정보 조회 로직 실행 */);
		// JWT 발급
		Map<String, String> tokens = jwtTokenUtil.generateTokenSet(aDTO.getAdmId(), rules);
		String accessToken = URLEncoder.encode(tokens.get("accessToken"), "utf-8");
		String refreshToken = URLEncoder.encode(tokens.get("refreshToken"), "utf-8");
		
		log.info("[JWT 발급] accessToken : " + accessToken);
		log.info("[JWT 발급] refreshToken : " + refreshToken);
		
		// JWT 쿠키 저장(쿠키 명 : token)
		Cookie cookie = new Cookie("jdhToken", "Bearer " + accessToken);
		cookie.setPath("/");
		cookie.setMaxAge(60 * 60 * 24 * 1); // 유효기간 1일
		// httoOnly 옵션을 추가해 서버만 쿠키에 접근할 수 있게 설정
		cookie.setHttpOnly(true);
		rep.addCookie(cookie);
		
		// 비밀번호 정보 제거
		aDTO.setAdmPw("");
		
		// refresh token 정보 저장/수정
		RefreshTokenDTO rDTO = new RefreshTokenDTO();
		rDTO.setAdmIdx(aDTO.getAdmIdx());
		rDTO.setRefreshToken("Bearer " + refreshToken);
		// ... DB에서 refresh token 정보 수정
		
		// local storage 사용 시 해당 return map에 access token 정보를 함께 반환해주면 됨
		returnMap.put("result", "success");
		returnMap.put("msg", "JWT가 발급되었습니다.");
		return returnMap;
	}
	
	// JWT 토큰 재발급
	@PostMapping(value="admin/refresh")
	public Map<String, Object> testJwtTokenRefresh(@RequestBody Map<String, Object> input, HttpServletRequest req, HttpServletResponse rep) throws Exception{
		Map<String, Object> returnMap = new HashMap<String, Object>();
		String refreshToken = null;
		String adminId = "";
		
		// 관리자 정보 조회
		AdminDTO aDTO = // ... DB에서 정보 조회 로직 실행
		
		// refreshToken 정보 조회
		RefreshTokenDTO rDTO = new RefreshTokenDTO();
		rDTO.setAdmIdx(aDTO.getAdmIdx());
		rDTO = // ... DB에서 refreshToken 정보 조회
		
		// token 정보가 존재하지 않는 경우
		if(rDTO == null) {
			returnMap.put("result", "fail");
			returnMap.put("msg", "refresh token 정보가 존재하지 않습니다.");
			return returnMap;
		}
		// token 정보가 존재하는 경우
		else {
			refreshToken = rDTO.getRefreshToken();
		}
		
		// refreshToken이 존재하는 경우 검증
		boolean tokenFl = false;
		try {
			refreshToken = refreshToken.substring(7);
			adminId = jwtTokenUtil.getUsernameFromToken(refreshToken);
			tokenFl = true;
		} catch (SignatureException e) {
			log.error("Invalid JWT signature: {}", e.getMessage());
		} catch (MalformedJwtException e) {
			log.error("Invalid JWT token: {}", e.getMessage());
		} catch (ExpiredJwtException e) {
			log.error("JWT token is expired: {}", e.getMessage());
		} catch (UnsupportedJwtException e) {
			log.error("JWT token is unsupported: {}", e.getMessage());
		} catch (IllegalArgumentException e) {
			log.error("JWT claims string is empty: {}", e.getMessage());
		}
		
		// refreshToken 사용이 불가능한 경우
		if(!tokenFl) {
			returnMap.put("result", "fail");
			returnMap.put("msg", "refresh token이 만료되었거나 정보가 존재하지 않습니다.");
			
			// ... refreshToken 정보 조회 실패 시 기존에 존재하는 refreshToken 정보 삭제
			
			return returnMap;
		}
		
		// refreshToken 인증 성공인 경우 accessToken 재발급
		if(adminId != null && !adminId.equals("")) {
			// 권한 map 저장
			Map<String, Object> rules = new HashMap<String, Object>();
			rules.put("rules", /* ... 권한 정보 조회 로직 실행 */);
			
			// JWT 발급
			String tokens = jwtTokenUtil.generateAccessToken(input.get("adminId").toString(), rules);
			String accessToken = URLEncoder.encode(tokens, "utf-8");
			
			log.info("[JWT 재발급] accessToken : " + accessToken);
			
			// JWT 쿠키 저장(쿠키 명 : token)
			Cookie cookie = new Cookie("jdhToken", "Bearer " + accessToken);
			cookie.setPath("/");
			cookie.setMaxAge(60 * 60 * 24 * 1); // 유효기간 1일
			// httoOnly 옵션을 추가해 서버만 쿠키에 접근할 수 있게 설정
			cookie.setHttpOnly(true);
			rep.addCookie(cookie);
			
			returnMap.put("result", "success");
			returnMap.put("msg", "JWT가 발급되었습니다.");
		}else {
			returnMap.put("result", "fail");
			returnMap.put("msg", "access token 발급 중 문제가 발생했습니다.");
			return returnMap;
		}
		
		return returnMap;
	}
	
	@Data
	class JwtRequest {
	private String email;
	private String password;
	}
	
	@Data
	@AllArgsConstructor
	class JwtResponse {
	private String token;
	}
}

 

필자가 개발하던 코드를 가져와 게시글에 없는(DTO, service 등) 부분이 있지만 결과적으로 로그인에 성공하면 Access Token, Refresh Token을 발급한다. 또, Access Token 재발급 요청 시 Refresh Token이 검증된 경우 Access Token을 쿠키에 다시 저장한다. 이 부분도 마찬가지로 local storage에 저장하는 방법으로 사용할 수 있다. 관련 사항은 코드에 주석으로 남겨놨으니 참고하면 된다.

 

 

정리하며

---

 

한 게시글에 모든 부분을 설명하려고 하다 보니 글이 길어졌다...

 

요즘은 scale up보다 scale out이 대세이다. 즉, 서버에 부하가 발생할 경우 서버 자체 스팩을 늘리는 것이 아니라, 서버를 여러대 두고 로드밸런싱을 하는 것이다. 이러한 방법을 사용할 경우 각기 다른 서버에 요청을 보내는 경우가 생긴다. session을 그냥 사용하는 경우에는 로그인 정보가 달라져 로그인이 풀릴 수 있다. 물론 redis 등 공통 캐싱DB를 사용하면 되지만, 이 역시 비용이 발생할 수 있다. 또, 성질이 다른 서버에서 공통으로 사용할 인증 로직으로 사용하기에는 적절하지 않을 수 있다.

 

JWT를 사용하면 위와 같은 클러스터링 환경에서 쉽게 인증 로직을 사용할 수 있을 것 같다.

 

관련 소스 코드는 깃허브를 참고하면 된다.

링크 : https://github.com/JangDaeHyeok/Spring-Security

GitHub - JangDaeHyeok/Spring-Security: Spring Security 세션, JWT 방식 구현

 

스프링 시큐리티 6.1 이후 버전 JWT 로그인 구현은 해당 글을 참고하면 된다.

링크 : https://jangjjolkit.tistory.com/72

[Spring Security] Spring Security (JWT, Access Token, Refresh Token) - Spring Security 6.1 이후

 

---

출저

https://mangkyu.tistory.com/56

https://llshl.tistory.com/32