[Spring Boot] Spring Security, JWT 토큰 인증

[Spring Boot] Spring Security, JWT 토큰 인증

2024. 11. 4. 16:40ㆍSpring/[2024] Spring Boot

728x90

조금의 시간이 남아 항상 미뤄왔던

스프링 부트에서 JWT 토큰을 사용해 로그인 기능을 구현하고, Spring Security로 인증을 관리하는 방법을 테스트 프로젝트 만들어보고, 티스토리에 정리해본다.!!

이번에 REST API 프로젝트의 인증방식으로 JWT 토큰을 사용했고, 이 부분을 내가 제대로 알고 있게 된 상황이 되어서,,,

미리 미리 공부하며 정리 해둔다 ㅠㅠ 😂😂

0️⃣ Spring Security, JWT 관련 라이브러리 추가

build.gardle

	implementation 'org.springframework.boot:spring-boot-starter-security'
	implementation 'io.jsonwebtoken:jjwt-impl:0.11.5'
	implementation 'io.jsonwebtoken:jjwt-jackson:0.11.5'
	implementation 'com.nimbusds:nimbus-jose-jwt:3.10'

* 전체 dependency

dependencies {
	implementation 'org.springframework.boot:spring-boot-starter-data-jpa'
	implementation 'org.springframework.boot:spring-boot-starter-web'
	compileOnly 'org.projectlombok:lombok'
	runtimeOnly 'com.h2database:h2'
	annotationProcessor 'org.projectlombok:lombok'
	testImplementation 'org.springframework.boot:spring-boot-starter-test'
	testImplementation 'org.springframework.security:spring-security-test'
	testRuntimeOnly 'org.junit.platform:junit-platform-launcher'

	implementation 'org.springframework.boot:spring-boot-starter-security'
	implementation 'io.jsonwebtoken:jjwt-impl:0.11.5'
	implementation 'io.jsonwebtoken:jjwt-jackson:0.11.5'
	implementation 'com.nimbusds:nimbus-jose-jwt:3.10'
}

1️⃣ JWT 유틸리티 클래스 작성 : JwtTokenProvider

jwt 토큰을 생성하고, 유효성 검증하는 클래스

package com.example.jwtoken.config.jwt;

import static com.example.jwtoken.common.JwtAuthErrorMessage.*;

import java.security.Key;
import java.util.Arrays;
import java.util.Date;
import java.util.List;
import java.util.stream.Collectors;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.authority.SimpleGrantedAuthority;
import org.springframework.security.core.userdetails.User;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.stereotype.Component;

import com.example.jwtoken.common.JwtAuthCode;
import com.example.jwtoken.common.JwtAuthErrorMessage;

import io.jsonwebtoken.Claims;
import io.jsonwebtoken.ExpiredJwtException;
import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.MalformedJwtException;
import io.jsonwebtoken.SignatureAlgorithm;
import io.jsonwebtoken.UnsupportedJwtException;
import io.jsonwebtoken.io.Decoders;
import io.jsonwebtoken.security.Keys;
import lombok.extern.slf4j.Slf4j;

@Slf4j
@Component
public class JwtTokenProvider
{

	@Value("${jwt.access.expired}")
	private long accessTokenExpired;

	@Value("${jwt.refresh.expired}")
	private long refreshTokenExpired;

	private final AuthenticationManagerBuilder authenticationManagerBuilder;
	private final Key key;

	public JwtTokenProvider(@Value("${jwt.secretKey}") String secretKey, AuthenticationManagerBuilder authenticationManagerBuilder)
	{
		this.authenticationManagerBuilder = authenticationManagerBuilder;
		byte[] keyBytes = Decoders.BASE64.decode(secretKey);
		this.key = Keys.hmacShaKeyFor(keyBytes);
	}


	/**
	 * 정보 가지고 AccessToken 생성 메서드
	 * @param authentication
	 * @return
	 */
	public String generateAccessToken(Authentication authentication)
	{
		// 0. 현재 인증된 사용자의 권한 정보 문자열 반환
		String authorities = getUserAuthToString(authentication);

		Date accessTokenExpiresIn = getExpiredDate(accessTokenExpired);

		return Jwts.builder()
				.setSubject(authentication.getName()) // 클레임에 현재 인증된 사용자 이름(id) 설정
				.claim(JwtAuthCode.AUTHORITIES_KEY.getKey(), authorities) // 추가 클레임으로 사용자 권한 정보
				.setExpiration(accessTokenExpiresIn) // 토큰 만료 시간
				.signWith(key, SignatureAlgorithm.HS256) // 토큰에 서명 추가, HMAC-SHA256 알고리즘 사용, 토큰 진위 검증할 때 지정
				.compact(); // 설정한 정보 바탕으로 JWT 생성 -> 문자열 반환
	}


	/**
	 * RefreshToken 생성 메서드
	 * @param id
	 * @return
	 */
	public String generateRefreshToken(String id)
	{
		Date now = new Date();
		Date refreshTokenExpiresIn = getExpiredDate(refreshTokenExpired);

		return Jwts.builder()
				.setIssuedAt(now) // IssuedAt : 클레임 JWT 발행 시간, 발행 시간 기반으로 토큰 재발행 상황 판단
				.setExpiration(refreshTokenExpiresIn)
				.signWith(key, SignatureAlgorithm.HS256)
				.compact();
	}

	/**
	 * JWT 토큰 복호화해서 토큰에 들어있는 정보 조회
	 * @param accessToken
	 * @return
	 */
	public Authentication getAuthentication(String accessToken)
	{
		// JWT 토큰 복호화
		Claims claims = parseClaims(accessToken);

		if (claims.get("auth") == null)
		{
			throw new IllegalArgumentException(JWT_AUTHENTICATION_NOT_VALID.getMessage());
		}

		// auth 클레임에서 권한 정보 가져오기
		List<SimpleGrantedAuthority> authorities = Arrays.stream(
						claims.get(JwtAuthCode.AUTHORITIES_KEY.getKey()).toString().split(","))
				.map(SimpleGrantedAuthority::new)
				.collect(Collectors.toList());

		UserDetails principal = new User(claims.getSubject(), "", authorities);
		return new UsernamePasswordAuthenticationToken(principal, "", authorities);
	}

	public Authentication setAuthentication(String id, String password)
	{
		Authentication authentication = null;

		UsernamePasswordAuthenticationToken authenticationToken = new UsernamePasswordAuthenticationToken(id, password);

		// authenticate 메서드를 통해 인증 검증 진행
		authentication = authenticationManagerBuilder.getObject().authenticate(authenticationToken);

		return authentication;
	}

	/**
	 * AccessToken 복호화
	 * @param accessToken
	 * @return
	 */
	public Claims parseClaims(String accessToken)
	{
		return Jwts.parserBuilder()
				.setSigningKey(key)
				.build()
				.parseClaimsJws(accessToken)
				.getBody();
	}

	/**
	 * 인증된 사용자의 권한을 문자열로 변환해 가져오는 메서드
	 * @param authentication
	 * @return
	 */
	private static String getUserAuthToString(Authentication authentication)
	{
		return authentication.getAuthorities().stream().map(GrantedAuthority::getAuthority).collect(Collectors.joining(","));
	}

	/**
	 * AccessToken 만료일 조회
	 * @return
	 */
	private Date getExpiredDate(long expiredDuration)
	{
		long now = new Date().getTime();
		return new Date(now + expiredDuration);
	}

	public boolean validateToken(String jwtToken)
	{
		try
		{
			Jwts.parserBuilder()
					.setSigningKey(key)
					.build()
					.parseClaimsJws(jwtToken);
			return true;
		}
		catch (SecurityException | MalformedJwtException e)
		{
			log.info(JTW_INVALID_TOKEN.getMessage(), e);
		}
		catch (ExpiredJwtException e)
		{
			log.info(JWT_EXPIRED_TOKEN.getMessage(), e);
		}
		catch (UnsupportedJwtException e)
		{
			log.info(JWT_UNSUPPORTED_TOKEN.getMessage(), e);
		}
		catch (IllegalArgumentException e)
		{
			log.info(JWT_CLAIMS_EMPTY.getMessage(), e);
		}
		return false;
	}
}

	/**
	 * 정보 가지고 AccessToken 생성 메서드
	 * @param authentication
	 * @return
	 */
	public String generateAccessToken(Authentication authentication)
	{
		// 0. 현재 인증된 사용자의 권한 정보 문자열 반환
		String authorities = getUserAuthToString(authentication);

		Date accessTokenExpiresIn = getExpiredDate(accessTokenExpired);

		return Jwts.builder()
				.setSubject(authentication.getName()) // 클레임에 현재 인증된 사용자 이름(id) 설정
				.claim(JwtAuthCode.AUTHORITIES_KEY.getKey(), authorities) // 추가 클레임으로 사용자 권한 정보
				.setExpiration(accessTokenExpiresIn) // 토큰 만료 시간
				.signWith(key, SignatureAlgorithm.HS256) // 토큰에 서명 추가, HMAC-SHA256 알고리즘 사용, 토큰 진위 검증할 때 지정
				.compact(); // 설정한 정보 바탕으로 JWT 생성 -> 문자열 반환
	}

-> 사용자가 인증됐을 때 JWT를 생성하는 메서드로 스프링 시큐리티의 Authentication 객체를 사용해 인증된 사용자 정보와 권한을 JWT에 담아 생성

.setSubject(authentication.getName())
-> 토큰의 subject 클레임에 현재 인증된 사용자의 이름 설정 (대부분 사용자 id)

.claim(JwtAuthCode.AUTHORITIES_KEY.getKey(), authorities)

-> 토큰에 추가적인 클레임으로 사용자의 권한 정보를 설정

.signWith(key, SignatureAlgorithm.HS256)

-> 토큰에 서명 추가

.compact()

-> 최종적으로 빌더 객체가 설정한 정보를 바탕으로 JWT를 생성하여 문자열로 반환

	/**
	 * RefreshToken 생성 메서드
	 * @param id
	 * @return
	 */
	public String generateRefreshToken(String id)
	{
		Date now = new Date();
		Date refreshTokenExpiresIn = getExpiredDate(refreshTokenExpired);

		return Jwts.builder()
				.setIssuedAt(now) // IssuedAt : 클레임 JWT 발행 시간, 발행 시간 기반으로 토큰 재발행 상황 판단
				.setExpiration(refreshTokenExpiresIn)
				.signWith(key, SignatureAlgorithm.HS256)
				.compact();
	}

-> generateRefreshToken 메서드는 리프레시 토큰을 생성한다.

리프레쉬 토큰은 액세스 토큰과 달리 주로 재인증할 때 사용하는 걸로 액세스 토큰에 비해 만료 시간이 더 길다.

.setIssuedAt(now)
-> jwt 가 발행된 시점에 현재 시간을 설정한다.

-> 서버가 리프레시 토큰의 발행 시간을 기반으로 토큰이 만료되었는지, 재발행해야 하는 상황인지 판단 가능하다.

.setExpiration(refreshTokenExpiresIn)

-> 토큰의 만료 시간을 설정한다. 이 만료 시간이 지나면 토큰이 더 이상 유효하지 않다.

	/**
	 * JWT 토큰 복호화해서 토큰에 들어있는 정보 조회
	 * @param accessToken
	 * @return
	 */
	public Authentication getAuthentication(String accessToken)
	{
		// JWT 토큰 복호화
		Claims claims = parseClaims(accessToken);

		if (claims.get("auth") == null)
		{
			throw new RuntimeExcpetion(JWT_AUTHENTICATION_NOT_VALID.getMessage());
		}

		// auth 클레임에서 권한 정보 가져오기
		List<SimpleGrantedAuthority> authorities = Arrays.stream(
						claims.get(JwtAuthCode.AUTHORITIES_KEY.getKey()).toString().split(","))
				.map(SimpleGrantedAuthority::new)
				.collect(Collectors.toList());

		UserDetails principal = new User(claims.getSubject(), "", authorities);
		return new UsernamePasswordAuthenticationToken(principal, "", authorities);
	}
    
    	/**
	 * AccessToken 복호화
	 * @param accessToken
	 * @return
	 */
	public Claims parseClaims(String accessToken)
	{
		return Jwts.parserBuilder()
				.setSigningKey(key)
				.build()
				.parseClaimsJws(accessToken)
				.getBody();
	}

-> getAuthentication 이 메서드는 JWT 토큰을 기반으로 사용자 인증 정보를 생성하고 반환한다.

Claims claims = parseClaims(accessToken);
-> accessToken을 Claims로 파싱해 JWT 에 담긴 정보 추출한다. parseClaims 메서드는 주어진 JWT 토큰을 해석해 페이로드에 포함된 클레임을 가져오는 메서드이다.

List<SimpleGrantedAuthority> authorities = Arrays.stream(...).map(...).collect(Collectors.toList());
-> 클레임 키를 찾아 권한 문자열을 가져오고

UserDetails principal = new User(claims.getSubject(), "", authorities);

-> User는 UserDetails 인터페이스를 구현한 객체로 User 객체는 Authentification 객체 생성 시 사용된다.

return new UsernamePasswordAuthenticationToken(principal, "", authorities);
-> 여기서 생성된 객체가 사용자에 대한 정보를 포함한다. 씨큐리티는 이 객체를 통해 사용자 인증 정보를 관리하고, 권한을 검사하며 액세스 제어할 때 사용한다.

	public Authentication setAuthentication(String id, String password)
	{
		Authentication authentication = null;

		UsernamePasswordAuthenticationToken authenticationToken = new UsernamePasswordAuthenticationToken(id, password);

		// authenticate 메서드를 통해 인증 검증 진행
		authentication = authenticationManagerBuilder.getObject().authenticate(authenticationToken);

		return authentication;
	}

authentication = authenticationManagerBuilder.getObject().authenticate(authenticationToken);
-> authenticate 메서드를 호출해 토큰에 담긴 id랑 비밀번호가 유효한지 검증 수행

2️⃣ Spring Security 설정 파일 : SecurityConfig

package com.example.jwtoken.config;

import java.util.HashMap;
import java.util.Map;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.method.configuration.EnableMethodSecurity;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configurers.AbstractHttpConfigurer;
import org.springframework.security.config.annotation.web.configurers.HeadersConfigurer;
import org.springframework.security.config.http.SessionCreationPolicy;
import org.springframework.security.crypto.factory.PasswordEncoderFactories;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.security.web.SecurityFilterChain;
import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;
import org.springframework.security.web.util.matcher.AntPathRequestMatcher;
import org.springframework.security.web.util.matcher.OrRequestMatcher;
import org.springframework.security.web.util.matcher.RequestMatcher;

import com.example.jwtoken.common.JwtAuthenticationEntryPoint;
import com.example.jwtoken.config.jwt.JwtAuthenticationFilter;
import com.example.jwtoken.config.jwt.JwtTokenProvider;

@Configuration
@EnableMethodSecurity
public class SecurityConfig
{

	private final JwtTokenProvider jwtTokenProvider;
	private final JwtAuthenticationEntryPoint jwtAuthenticationEntryPoint;

	public SecurityConfig(JwtTokenProvider jwtTokenProvider, JwtAuthenticationEntryPoint jwtAuthenticationEntryPoint)
	{
		this.jwtTokenProvider = jwtTokenProvider;
		this.jwtAuthenticationEntryPoint = jwtAuthenticationEntryPoint;
	}

	@Bean
	public Map<String, RequestMatcher> publicEndPointMatcher()
	{
		Map<String, RequestMatcher> requestMatcherMap = new HashMap<>();
		requestMatcherMap.put("local", new OrRequestMatcher(
				new AntPathRequestMatcher("/**/**")
		));

		return requestMatcherMap;
	}

	@Bean
	public SecurityFilterChain filterChain(HttpSecurity http) throws Exception
	{
		// CSRF 비활성화 -> REST API의 경우 CSRF 보호 필요 X, 토큰 기반 인증 사용할 경우 세션 사용도 안하므로 적용 X
		// 모든 요청에 JWT 토큰 인증을 수행, REST API는 보통 무상태(STATELESS) 방식을 사용하므로 세션 사용 X
		// header.frameOptions(HeadersConfigurer.FrameOptionsConfig::disable) -> X-Freame-Options 헤더 비활성화, 현재 페이지 로드 차단
		http
				.csrf(AbstractHttpConfigurer::disable)
				.sessionManagement(session -> session.sessionCreationPolicy(SessionCreationPolicy.STATELESS))
				.headers(header -> header.frameOptions(HeadersConfigurer.FrameOptionsConfig::disable))
				.authorizeHttpRequests(auth -> auth.requestMatchers(
						publicEndPointMatcher().get("local")).permitAll()
						.anyRequest().authenticated()
				)
				.addFilterBefore(new JwtAuthenticationFilter(jwtTokenProvider), UsernamePasswordAuthenticationFilter.class)
				.exceptionHandling(httpSecurityExceptionHandlingConfigurer ->
						httpSecurityExceptionHandlingConfigurer.authenticationEntryPoint(jwtAuthenticationEntryPoint))
				;

		return http.build();
	}

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


}

@EnableMethodSecurity:메서드 단위의 보안 설정 활성화, @PreAuthorize 같은 어노테이션 통해 메서드 접근 제어 가능

jwtTokenProvider : JWT 토큰 생성하고 검증하는 역할하는 클래스

jwtAuthenticationEntryPoint : 인증 오류 발생했을 때 오류 응답 처리하는 클래스

@Bean
public Map<String, RequestMatcher> publicEndPointMatcher() {
	Map<String, RequestMatcher> requestMatcherMap = new HashMap<>();
	requestMatcherMap.put("local", new OrRequestMatcher(
			new AntPathRequestMatcher("/**/**")
	));
	return requestMatcherMap;
}

-> 지금은 테스트 프로젝트라 모든 경로를 우선 허용하는 공개 포인트로 지정했다.
(원래 이렇게 하면 당연히 XX)

@Bean
public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
	http
		.csrf(AbstractHttpConfigurer::disable)
		.sessionManagement(session -> session.sessionCreationPolicy(SessionCreationPolicy.STATELESS))
		.headers(header -> header.frameOptions(HeadersConfigurer.FrameOptionsConfig::disable))
		.authorizeHttpRequests(auth -> auth.requestMatchers(
				publicEndPointMatcher().get("local")).permitAll()
				.anyRequest().authenticated()
		)
		.addFilterBefore(new JwtAuthenticationFilter(jwtTokenProvider), UsernamePasswordAuthenticationFilter.class)
		.exceptionHandling(httpSecurityExceptionHandlingConfigurer ->
				httpSecurityExceptionHandlingConfigurer.authenticationEntryPoint(jwtAuthenticationEntryPoint));
	return http.build();
}

.csrf(AbstractHttpConfigurer::disable): CSRF 보호를 비활성화

-> REST API나 JWT 기반 인증에서는 CSRF 보호가 필요하지 않기 때문에 비활성화 한다.

.sessionManagement(session -> session.sessionCreationPolicy(SessionCreationPolicy.STATELESS))
-> REST API는 일반적으로 무상태성을 유지하기 때문에 세션을 생성하지 않는다.

.headers(header -> header.frameOptions(HeadersConfigurer.FrameOptionsConfig::disable))

-> X-Frame-Options 헤더를 비활성화한다. 웹 애플리케이션이 특정 페이지에서 프레임을 통해 다른 페이지로 로드하는 것을 차단할 수 있다.

.addFilterBefore(new JwtAuthenticationFilter(jwtTokenProvider), UsernamePasswordAuthenticationFilter.class):

-> 요청마다 jwt 토큰을 확인하고 유효성 검증하는 필터로 UsernamePasswordAuthenticationFilter 이전에 실행됨

.exceptionHandling(...):인증 오류 발생했을 때 JwtAuthenticationEntryPoint 사용해 예외 처리

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

-> 비밀번호 암호화 메서드로 기본적으로는 BCryptPasswordEncoder 를 사용해 비밀번호를 암호화한다.

3️⃣ JWT 인증 필터 : JwtAuthenticationFilter

JWT 토큰을 파싱해 SecurityContext에 인증 정보를 추가해주는 필터 클래스

package com.example.jwtoken.config.jwt;

import java.io.IOException;

import org.springframework.security.core.Authentication;
import org.springframework.security.core.context.SecurityContextHolder;

import jakarta.servlet.FilterChain;
import jakarta.servlet.GenericFilter;
import jakarta.servlet.ServletException;
import jakarta.servlet.ServletRequest;
import jakarta.servlet.ServletResponse;
import jakarta.servlet.http.HttpServletRequest;

public class JwtAuthenticationFilter extends GenericFilter
{
	private final JwtTokenProvider jwtTokenProvider;

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

	@Override
	public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException
	{
		String jwtToken = getJwtFromRequest((HttpServletRequest) servletRequest);

		if (jwtToken != null && jwtTokenProvider.validateToken(jwtToken))
		{
			Authentication authentication = jwtTokenProvider.getAuthentication(jwtToken);
			SecurityContextHolder.getContext().setAuthentication(authentication);

			filterChain.doFilter(servletRequest, servletResponse);
		}
	}

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

-> 요청 헤더에 토큰이 null 이 아니고 유효하다면 SecurityContextHodler에 인증된 사용자 정보를 저장하고, 이후 요청에서 이 정보를 사용할 수 있다.

filterChain.doFilter(request, response)
-> doFilter 메서드를 호출해 다음 필터로 요청 전달한다.

4️⃣ JwtAuthenticationEntryPoint

Spring Security에서 인증되지 않은 사용자가 리소스 접근하려 할 때 호출되는 클래스

@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");
	}
}

-> AuthentificationEntryPoint 인터페이스를 구현하고, 인증 오류가 발생했을 때 처리하는 방법 정의

여기서는 인증되지 않은 사용자가 접근하려고 하면 401 오류 응답을 반환한다.

👩‍💻 오늘은 우선 여기까지 구현하고, 다음엔 로그인 및 회원 가입을 만들 예정이다.

728x90

'Spring > [2024] Spring Boot' 카테고리의 다른 글

간단한 Spring Boot Restful API Sample Project 만들어보기 #2. 회원가입 구현하기 (0)	2024.03.11
간단한 Spring Boot Restful API Sample Project 만들어보기 #1. Spring Security 설정 + CustomFilter 만들기 (0)	2024.03.07
Spring REST Docs 를 사용해 문서 자동화하는 방법 + 샘플 프로젝트 작성 (Spring +JPA) (1)	2024.02.27
[Spring] 네이버 로그인 API 사용하는 방법 (0)	2024.02.07
[Spring] 카카오 로그인 API 사용하는 방법 (1)	2024.02.07

💖💗

💖💗

태그

최근글

댓글

공지사항

아카이브

'Spring > [2024] Spring Boot' 카테고리의 다른 글

관련글

티스토리툴바