JWT x SpringSecurity

plugins { id 'java' id 'war' id 'org.springframework.boot' version '2.7.18' id 'io.spring.dependency-management' version '1.1.4' } group = 'com.aloha' version = '0.0.1-SNAPSHOT' java { toolchain { languageVersion = JavaLanguageVersion.of(17) } } configurations { compileOnly { extendsFrom annotationProcessor } } repositories { mavenCentral() } dependencies { implementation 'org.springframework.boot:spring-boot-starter-security' implementation 'org.springframework.boot:spring-boot-starter-web' compileOnly 'org.projectlombok:lombok' developmentOnly 'org.springframework.boot:spring-boot-devtools' annotationProcessor 'org.projectlombok:lombok' providedRuntime 'org.springframework.boot:spring-boot-starter-tomcat' testImplementation 'org.springframework.boot:spring-boot-starter-test' testImplementation 'org.springframework.security:spring-security-test' // spring-boot-configuration-processor implementation 'org.springframework.boot:spring-boot-configuration-processor' // jwt implementation 'io.jsonwebtoken:jjwt-api:0.12.3' runtimeOnly 'io.jsonwebtoken:jjwt-impl:0.12.3' runtimeOnly 'io.jsonwebtoken:jjwt-jackson:0.12.3' } tasks.named('test') { useJUnitPlatform() }

@Data public class Users { private int no; private String userId; private String userPw; private String userPwCheck; // 비밀번호 확인 private String name; private String email; private Date regDate; private Date updDate; private int enabled; // 휴면여부 // 권한 목록 List<UserAuth> authList; public Users() { } public Users(Users user) { this.no = user.getNo(); this.userId = user.getUserId(); this.userPw = user.getUserPw(); this.name = user.getName(); this.email = user.getEmail(); this.authList = user.getAuthList(); } }

// 회원 권한 @Data public class UserAuth { private int authNo; private String userId; private String auth; public UserAuth() { } public UserAuth(String userId, String auth) { this.userId = userId; this.auth = auth; } }

<?xml version="1.0" encoding="UTF-8" ?> <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd"> <mapper namespace="com.aloha.jwt_security.mapper.UserMapper"> <!-- Users 매핑--> <resultMap type="Users" id="userMap"> <id property="no" column="no" /> <result property="no" column="no" /> <result property="userId" column="user_id" /> <result property="userPw" column="user_pw" /> <result property="name" column="name" /> <result property="email" column="email" /> <result property="enabled" column="enabled" /> <result property="regDate" column="reg_date" /> <result property="updDate" column="upd_date" /> <collection property="authList" resultMap="authMap"></collection> </resultMap> <!-- UserAuth 매핑 --> <resultMap type="UserAuth" id="authMap"> <result property="userId" column="user_id" /> <result property="auth" column="auth" /> </resultMap> <!-- 회원 등록 --> <insert id="insert"> INSERT INTO user( user_id, user_pw, name, email ) VALUES ( #{userId}, #{userPw}, #{name} ,#{email} ) </insert> <!-- 회원 조회 --> <select id="select" resultType="Users"> SELECT * FROM user WHERE no = #{no} </select> <!-- 회원 조회 - id --> <select id="login" resultMap="userMap"> SELECT u.no ,u.user_id ,user_pw ,name ,email ,enabled ,reg_date ,upd_date ,auth FROM user u LEFT OUTER JOIN user_auth auth ON u.user_id = auth.user_id WHERE u.user_id = #{userId} </select> <!-- 회원 권한 등록 --> <insert id="insertAuth"> INSERT INTO user_auth( user_id, auth ) VALUES ( #{userId}, #{auth} ) </insert> <!-- 회원 수정 --> <update id="update"> UPDATE user SET user_id = #{userId} ,user_pw = #{userPw} ,name = #{name} ,email = #{email} WHERE user_id = #{userId} </update> <!-- 회원 삭제 --> <delete id="delete"> DELETE FROM user WHERE user_id = #{userId} </delete> </mapper>

@Mapper public interface UserMapper { // 회원 등록 public int insert(Users user) throws Exception; // 회원 조회 public Users select(int userNo) throws Exception; // 사용자 인증(로그인) - id public Users login(String username); // 회원 권한 등록 public int insertAuth(UserAuth userAuth) throws Exception; // 회원 수정 public int update(Users user) throws Exception; // 회원 삭제 public int delete(String userId) throws Exception; }

public interface UserService { // 회원 등록 public int insert(Users user) throws Exception; // 회원 조회 public Users select(int userNo) throws Exception; // 로그인 public void login(Users user, HttpServletRequest requset) throws Exception; // 회원 수정 public int update(Users user) throws Exception; // 회원 삭제 public int delete(String userId) throws Exception; }

@Slf4j @Service public class UserServiceImpl implements UserService { @Autowired private UserMapper userMapper; @Autowired private PasswordEncoder passwordEncoder; @Autowired private AuthenticationManager authenticationManager; @Override public int insert(Users user) throws Exception { // 비밀번호 암호화 String userPw = user.getUserPw(); String encodedPw = passwordEncoder.encode(userPw); user.setUserPw(encodedPw); // 회원 등록 int result = userMapper.insert(user); // 권한 등록 if( result > 0 ) { UserAuth userAuth = new UserAuth(); userAuth.setUserId( user.getUserId() ); userAuth.setAuth("ROLE_USER"); // 기본 권한 : 사용자 권한 (ROLE_USER) result = userMapper.insertAuth(userAuth); } return result; } @Override public Users select(int userNo) throws Exception { return userMapper.select(userNo); } @Override public void login(Users user, HttpServletRequest requset) throws Exception { String username = user.getUserId(); String password = user.getUserPwCheck(); log.info("username : " + username); log.info("password : " + password); // 아이디, 패스워드 인증 토큰 생성 UsernamePasswordAuthenticationToken token = new UsernamePasswordAuthenticationToken(username, password); // 토큰에 요청정보를 등록 token.setDetails( new WebAuthenticationDetails(requset) ); // 토큰을 이용하여 인증(로그인) Authentication authentication = authenticationManager.authenticate(token); User authUser = (User) authentication.getPrincipal(); log.info("인증된 사용자 아이디 : " + authUser.getUsername()); SecurityContextHolder.getContext().setAuthentication(authentication); } @Override public int update(Users user) throws Exception { // 비밀번호 암호화 String userPw = user.getUserPw(); String encodedPw = passwordEncoder.encode(userPw); user.setUserPw(encodedPw); int result = userMapper.update(user); return result; } @Override public int delete(String userId) throws Exception { int result = userMapper.delete(userId); return result; } }

public final class SecurityConstants { // 🔗 로그인 경로 public static final String AUTH_LOGIN_URL = "/login"; // 🎫 인증 요청 헤더 // Authorization : "Bearer " + 💍(JWT) public static final String TOKEN_HEADER = "Authorization"; public static final String TOKEN_PREFIX = "Bearer "; public static final String TOKEN_TYPE = "JWT"; }

@Getter @Setter @ToString public class AuthenticationRequest { private String username; private String password; }

@Data @Component @ConfigurationProperties("com.aloha.jwt") // com.aloha.jwt 경로 하위 속성들을 지정 public class JwtProps { // com.aloha.jwt.secretKey로 지정된 프로퍼티 값을 주입받는 필드 // ✅ com.aloha.jwt.secret-key ➡ secretKey : {인코딩된 시크릿 키} private String secretKey; }

@Slf4j @Configuration @EnableWebSecurity @EnableGlobalMethodSecurity(prePostEnabled = true, securedEnabled = true) //어노테이션에 prePostEnabled = true를 추가하면 AuthenticationManager를 자동으로 구성합니다. public class SecurityConfig { @Autowired private CustomUserDetailService customUserDetailService; @Autowired private JwtTokenProvider jwtTokenProvider; private AuthenticationManager authenticationManager; @Bean public AuthenticationManager authenticationManager(AuthenticationConfiguration authenticationConfiguration) throws Exception { this.authenticationManager = authenticationConfiguration.getAuthenticationManager(); return authenticationManager; } @Bean public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception { log.info("securityFilterChain..."); // 폼 기반 로그인 비활성화 http.formLogin( login -> login.disable() ); // HTTP 기본 인증 비활성화 http.httpBasic( basic -> basic.disable() ); // CSRF(Cross-Site Request Forgery) 공격 방어 기능 비활성화 http.csrf( csrf -> csrf.disable() ); // 필터 설정 // ✅ JWT 요청 필터 1️⃣ // ✅ JWT 인증 필터 2️⃣ http.addFilterAt(new JwtAuthenticationFilter(authenticationManager, jwtTokenProvider), UsernamePasswordAuthenticationFilter.class) .addFilterBefore(new JwtRequestFilter(authenticationManager, jwtTokenProvider), UsernamePasswordAuthenticationFilter.class) ; // 인가 설정 http.authorizeHttpRequests() .requestMatchers(PathRequest.toStaticResources().atCommonLocations()).permitAll() .antMatchers("/").permitAll() .antMatchers("/login").permitAll() .antMatchers("/user/**").hasAnyRole("USER" , "ADMIN") .antMatchers("/admin/**").hasRole("ADMIN") // .anyRequest().authenticated() ; // 사용자 정보를 불러오는 서비스 설정 http.userDetailsService(customUserDetailService); return http.build(); } @Bean public PasswordEncoder passwordEncoder() { return new BCryptPasswordEncoder(); } }

@Getter @ToString public class CustomUser implements UserDetails { private Users user; public CustomUser(Users user) { this.user = user; } /** * 🟢🟡🔴 권한 getter 메소드 * ✅ UserDetails 를 CustomUser 로 구현하여, * Spring Security 의 User 대신 사용자 정의 인증 객체(CustomUser)를 사용한다면, * 권한은 'ROLE_' 붙여서 사용해야한다. */ @Override public Collection<? extends GrantedAuthority> getAuthorities() { return user.getAuthList().stream() .map( (auth) -> new SimpleGrantedAuthority(auth.getAuth())) .collect(Collectors.toList()); } @Override public String getPassword() { return user.getUserPw(); } @Override public String getUsername() { return user.getUserId(); } @Override public boolean isAccountNonExpired() { return true; } @Override public boolean isAccountNonLocked() { return true; } @Override public boolean isCredentialsNonExpired() { return true; } @Override public boolean isEnabled() { return user.getEnabled() == 0 ? false : true; } }

@Slf4j @Service public class CustomUserDetailService implements UserDetailsService { @Autowired private UserMapper userMapper; @Override public UserDetails loadUserByUsername(String username) { log.info("login - loadUserByUsername : " + username); // MyBatis를 사용하여 데이터베이스에서 사용자 세부 정보를 가져옵니다. Users user = userMapper.login(username); if (user == null) { log.info("사용자 없음..."); throw new UsernameNotFoundException("사용자를 찾을 수 없습니다: " + username); } log.info("user :::::"); log.info(user.toString()); // 🟢🟡🔴 CustomUser (➡User) 사용 CustomUser customUser = new CustomUser(user); log.info("customuser :::::"); log.info(customUser.toString()); return customUser; } }

/** * 🔐 JWT 토큰 관련 기능을 제공해주는 클래스 * ✅ 토큰 생성 * ✅ 토큰 해석 * ✅ 토큰 유효성 검사 */ @Slf4j @Component public class JwtTokenProvider { @Autowired private JwtProps jwtProps; @Autowired private UserMapper userMapper; /* * 👩‍💼➡🔐 토큰 생성 */ public String createToken(int userNo, String userId, List<String> roles) { byte[] signingKey = getSigningKey(); // JWT 토큰 생성 String jwt = Jwts.builder() .signWith(Keys.hmacShaKeyFor(signingKey), Jwts.SIG.HS512) // 서명에 사용할 키와 알고리즘 설정 // .setHeaderParam("typ", SecurityConstants.TOKEN_TYPE) // deprecated (version: before 1.0) .header() // update (version : after 1.0) .add("typ", SecurityConstants.TOKEN_TYPE) // 헤더 설정 .and() .expiration(new Date(System.currentTimeMillis() + 864000000)) // 토큰 만료 시간 설정 (10일) .claim("uno", "" + userNo) // 클레임 설정: 사용자 번호 .claim("uid", userId) // 클레임 설정: 사용자 아이디 .claim("rol", roles) // 클레임 설정: 권한 .compact(); log.info("jwt : " + jwt); return jwt; } /** * 🔐➡👩‍💼 토큰 해석 * * Authorization : Bearer + {jwt} (authHeader) * ➡ jwt 추출 * ➡ UsernamePasswordAuthenticationToken * @param authHeader * @return * @throws Exception */ public UsernamePasswordAuthenticationToken getAuthentication(String authHeader) { if(authHeader == null || authHeader.length() == 0 ) return null; try { // jwt 추출 String jwt = authHeader.replace("Bearer ", ""); // 🔐➡👩‍💼 JWT 파싱 Jws<Claims> parsedToken = Jwts.parser() .verifyWith(getShaKey()) .build() .parseSignedClaims(jwt); log.info("parsedToken : " + parsedToken); // 인증된 사용자 번호 String userNo = parsedToken.getPayload().get("uno").toString(); int no = ( userNo == null ? 0 : Integer.parseInt(userNo) ); log.info("userNo : " + userNo); // 인증된 사용자 아이디 String userId = parsedToken.getPayload().get("uid").toString(); log.info("userId : " + userId); // 인증된 사용자 권한 Claims claims = parsedToken.getPayload(); Object roles = claims.get("rol"); log.info("roles : " + roles); // 토큰에 userId 있는지 확인 if( userId == null || userId.length() == 0 ) return null; Users user = new Users(); user.setNo(no); user.setUserId(userId); // OK: 권한도 바로 Users 객체에 담아보기 List<UserAuth> authList = ((List<?>) roles ) .stream() .map(auth -> new UserAuth(userId, auth.toString()) ) .collect( Collectors.toList() ); user.setAuthList(authList); // OK // CustomeUser 에 권한 담기 List<SimpleGrantedAuthority> authorities = ((List<?>) roles ) .stream() .map(auth -> new SimpleGrantedAuthority( (String) auth )) .collect( Collectors.toList() ); // 토큰 유효하면 // name, email 도 담아주기 try { Users userInfo = userMapper.select(no); if( userInfo != null ) { user.setName(userInfo.getName()); user.setEmail(userInfo.getEmail()); } } catch (Exception e) { log.error(e.getMessage()); log.error("토큰 유효 -> DB 추가 정보 조회시 에러 발생..."); } UserDetails userDetails = new CustomUser(user); // OK // new UsernamePasswordAuthenticationToken( 사용자정보객체, 비밀번호, 사용자의 권한(목록) ); return new UsernamePasswordAuthenticationToken(userDetails, null, authorities); } catch (ExpiredJwtException exception) { log.warn("Request to parse expired JWT : {} failed : {}", authHeader, exception.getMessage()); } catch (UnsupportedJwtException exception) { log.warn("Request to parse unsupported JWT : {} failed : {}", authHeader, exception.getMessage()); } catch (MalformedJwtException exception) { log.warn("Request to parse invalid JWT : {} failed : {}", authHeader, exception.getMessage()); } catch (IllegalArgumentException exception) { log.warn("Request to parse empty or null JWT : {} failed : {}", authHeader, exception.getMessage()); } return null; } // /** * 🔐❓ 토큰 유효성 검사 * @param jwt * @return * ⭕ true : 유효 * ❌ false : 만료 */ public boolean validateToken(String jwt) { try { // 🔐➡👩‍💼 JWT 파싱 Jws<Claims> claims = Jwts.parser() .verifyWith(getShaKey()) .build() .parseSignedClaims(jwt); log.info("::::: 토큰 만료기간 :::::"); log.info("-> " + claims.getPayload().getExpiration()); /* PAYLOAD { "exp": 1703140095, ⬅ 만료기한 추출 "uid": "joeun", "rol": [ "ROLE_USER" ] } */ return !claims.getPayload().getExpiration().before(new Date()); } catch (ExpiredJwtException exception) { log.error("Token Expired"); // 토큰 만료 return false; } catch (JwtException exception) { log.error("Token Tampered"); // 토큰 손상 return false; } catch (NullPointerException exception) { log.error("Token is null"); // 토큰 없음 return false; } catch (Exception e) { return false; } } // secretKey ➡ signingKey private byte[] getSigningKey() { return jwtProps.getSecretKey().getBytes(); } // secretKey ➡ (HMAC-SHA algorithms) ➡ signingKey private SecretKey getShaKey() { return Keys.hmacShaKeyFor(getSigningKey()); } }

@Slf4j public class JwtAuthenticationFilter extends UsernamePasswordAuthenticationFilter { private final AuthenticationManager authenticationManager; private final JwtTokenProvider jwtTokenProvider; // 생성자 public JwtAuthenticationFilter( AuthenticationManager authenticationManager, JwtTokenProvider jwtTokenProvider ) { this.authenticationManager = authenticationManager; this.jwtTokenProvider = jwtTokenProvider; // 🔗 필터 URL 경로 설정 : /login setFilterProcessesUrl(SecurityConstants.AUTH_LOGIN_URL); } /** * 🔐 인증 시도 메소드 * : /login 경로로 (username, password) 를 요청하면 이 필터에서 걸려 인증을 시도합니다. * ✅ Authentication 인증 시도한 사용자 인증 객체를 반환하여, 시큐리티가 인증 성공 여부를 판단하게 합니다. * @param request * @param response * @return * @throws AuthenticationException */ @Override public Authentication attemptAuthentication(HttpServletRequest request, HttpServletResponse response) throws AuthenticationException { String username = request.getParameter("username"); String password = request.getParameter("password"); log.info("username : " + username); log.info("password : " + password); // 사용자 인증정보 객체 생성 Authentication authentication = new UsernamePasswordAuthenticationToken(username, password); // 사용자 인증 (로그인) authentication = authenticationManager.authenticate(authentication); /* 🔐 authenticate() 인증 처리 프로세스 1️⃣ 주어진 Authentication 객체에서 사용자의 아이디를 추출합니다. 2️⃣ UserDetailsService를 사용하여 해당 아이디에 대한 UserDetails 객체를 가져옵니다. 3️⃣ 가져온 UserDetails 객체에서 저장된 비밀번호를 확인하기 위해 PasswordEncoder를 사용합니다. 4️⃣ 사용자가 제공한 비밀번호와 저장된 비밀번호가 일치하는지 확인합니다. 5️⃣ 인증이 성공하면, 새로운 Authentication 객체를 생성하여 반환합니다. ✅ 인증 여부를, isAuthenticated() ➡ true 로 확인할 수 있습니다. */ log.info("authenticationManager : " + authenticationManager); log.info("authentication : " + authentication); log.info("인증 여부(isAuthenticated) : " + authentication.isAuthenticated()); // 인증 실패 (username, password 불일치) if( !authentication.isAuthenticated() ) { log.info("인증 실패 : 아이디와 비밀번호가 일치하지 않습니다."); response.setStatus(401); } return authentication; } /** * ⭕ 인증 성공 메소드 * : attemptAuthentication() 호출 후, 반환된 Authentication - 사용자 인증 객체가 인증된 것이 확인되면, 호출됩니다. * * ➡ 🔐 JWT * : 로그인 인증에 성공했으므로, JWT 토큰을 생성하여 * 응답(response) 헤더에 jwt 토큰을 담아 응답합니다. * 💍 { Authorization : Bearer + {jwt} } * @param request * @param response * @param chain * @param authentication * @throws IOException * @throws ServletException */ @Override protected void successfulAuthentication(HttpServletRequest request, HttpServletResponse response, FilterChain chain, Authentication authentication) throws IOException, ServletException { log.info("인증 성공 (auth SUCCESS) : "); CustomUser user = ((CustomUser) authentication.getPrincipal()); int userNo = user.getUser().getNo(); String userId = user.getUser().getUserId(); List<String> roles = user.getAuthorities() .stream() .map(GrantedAuthority::getAuthority) .collect(Collectors.toList()); // 🔐 JWT String token = jwtTokenProvider.createToken(userNo, userId, roles); // 💍 { Authorization : Bearer + {jwt} } response.addHeader(SecurityConstants.TOKEN_HEADER, SecurityConstants.TOKEN_PREFIX + token); response.setStatus(200); } }

@Slf4j public class JwtRequestFilter extends OncePerRequestFilter { private final AuthenticationManager authenticationManager; private final JwtTokenProvider jwtTokenProvider; // 생성자 public JwtRequestFilter( AuthenticationManager authenticationManager, JwtTokenProvider jwtTokenProvider ) { this.authenticationManager = authenticationManager; this.jwtTokenProvider = jwtTokenProvider; } @Override protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException { // HTTP 헤더에서 토큰을 가져옴 String header = request.getHeader(SecurityConstants.TOKEN_HEADER); log.info("authorization : " + header); //✅ Bearer + {jwt} 체크 // 헤더가 없거나 형식이 올바르지 않으면 다음 필터로 진행 if (header == null || header.length() == 0 || !header.startsWith(SecurityConstants.TOKEN_PREFIX)) { filterChain.doFilter(request, response); return; } // 🔐 JWT // Bearer + ${jwt} ➡ "Bearer " 제거 String jwt = header.replace(SecurityConstants.TOKEN_PREFIX, ""); // 토큰을 사용하여 Authentication 객체 생성 Authentication authentication = jwtTokenProvider.getAuthentication(jwt); // 토큰 유효 검사 (토큰이 만료되지 않았으면) if( jwtTokenProvider.validateToken(jwt) ) { log.info("유효한 JWT 토큰입니다."); // 👩‍💼 [로그인] // SecurityContextHolder(사용자 보안정보를 담는 객체)에 // Authentication(사용자 인증 정보) 객체를 설정 SecurityContextHolder.getContext().setAuthentication(authentication); } // 다음 필터로 진행 filterChain.doFilter(request, response); } }