JWT #3

💙 UsernamePasswordAuthenticationToken

Spring Security에서 사용자의 인증 정보를 담는 객체

Authentication 인터페이스를 구현한 클래스이며 "현재 사용자가 누구인지", "어떤 권한을 가지고 있는지" 를 나타낸다.

💚 생성자 정리

인증 전 (로그인 시 사용)

new UsernamePasswordAuthenticationToken(username, password);

• 아직 인증되지 않은 상태
• 스프링 시큐리티 내부에서 로그인 시도할 때 사용
• isAuthenticated() → false

인증 후 (JWT 검증 완료 후 사용)

new UsernamePasswordAuthenticationToken(principal, credentials, authorities);

• 인증된 사용자 정보로 생성
• 예 : principal = username, credentials = null, authorities = ROLE_USER
• isAuthenticated() -> true

isAuthenticated()

Authentication 인터페이스의 메소드 중 하나로, 현재 Authentication 객체가 정상적으로 인증되었는지(true) 또는 그렇지 않은지(false)를 반환

상황	예시	isAuthenticated() 값
인증 전 (로그인 시도 단계)	new UsernamePasswordAuthenticationToken(username, password)	false
인증 후 (JWT 검증 완료 등)	new UsernamePasswordAuthenticationToken(username, null, 권한목록)	true

// 로그인 시도 (인증 전)
UsernamePasswordAuthenticationToken unauthenticated =
    new UsernamePasswordAuthenticationToken("user", "1234");

System.out.println(unauthenticated.isAuthenticated());  // false

JWT 인증 후 (인증 완료)
List<GrantedAuthority> authorities = List.of(new SimpleGrantedAuthority("ROLE_USER"));
UsernamePasswordAuthenticationToken authenticated =
    new UsernamePasswordAuthenticationToken("user", null, authorities);

System.out.println(authenticated.isAuthenticated());  // true

💙 SimpleGrantedAuthority

GrantedAuthority 인터페이스를 구현한 클래스 중 하나로 "이 사용자가 어떤 권한(역할)을 가지고 있는가?" 를 나타낸다.

사용자의 권한(Role)을 표현할때 사용하는 클래스 (예 : ROLE_USER, ROLE_ADMIN )

사용 예시

String role = "USER";

UsernamePasswordAuthenticationToken authentication =
    new UsernamePasswordAuthenticationToken(
        username,
        null,
        Collections.singleton(new SimpleGrantedAuthority("ROLE_" + role))
    );

여기서 "ROLE_" + role → "ROLE_USER"
이 권한 정보가 Authentication 객체에 포함되어 컨트롤러나 보안 설정에서 사용된다.

@PreAuthorize("hasRole('USER')") // 내부적으로 ROLE_USER를 기대
public void viewUserData() {
    ...
}

// 둘 다 사용 가능

http.authorizeHttpRequests()
    .requestMatchers("/admin/**").hasRole("ADMIN")

💙 CustomUserDetails

사용자의 인증 정보를 담는 사용자 정의 클래스

Spring Security에서 UserDetails를 커스터마이징한 클래스로 Spring Security에서 인증을 처리할 때 UserDetailsService의 loadUserByUsername() 메소드를 통해 반환되는 객체는 UserDetails 인터페이스를 구현한 클래스여야 한다.

UserDetails 인터페이스를 구현한 클래스 -> CustomUserDetails
public class CustomUserDetails implements UserDetails

주요 역할

• 사용자의 아이디, 비밀번호 권한 등의 정보를 담음
• Spring Security가 인증 처리를 할 때 참조

public class CustomUserDetails implements UserDetails {

    private final User user;

    public CustomUserDetails(User user) {
        this.user = user;
    }

    @Override
    public Collection<? extends GrantedAuthority> getAuthorities() {
        return Collections.singleton(new SimpleGrantedAuthority("ROLE_" + user.getRole()));
    }

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

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

    // 계정 만료, 잠금 등의 기본값 처리
    @Override public boolean isAccountNonExpired() { return true; }
    @Override public boolean isAccountNonLocked() { return true; }
    @Override public boolean isCredentialsNonExpired() { return true; }
    @Override public boolean isEnabled() { return true; }

    public User getUser() {
        return user;
    }
}

사용 흐름

1. 사용자가 로그인 시도
2. UserDetailSErvice가 DB에서 사용자 정보 조회
3. CustomerUserDetails로 감싸서 반환
4. Spring Security가 내부에서 이 정보를 이용해 인증 진행

💙 SecurityContextHolder

Spring Security에서 현재 실행 중인 스레드의 보안 컨텍스트를 저장/조회하는 클래스로 인증 정보를 thread-safe하게 저장하는 전역 저장소 역할을 한다.

public class SecurityContextHolder {
    // 현재 스레드에 인증 정보를 저장하기 위한 ThreadLocal
    private static final ThreadLocal<SecurityContext> contextHolder = new ThreadLocal<>();

    public static SecurityContext getContext();
    public static void setContext(SecurityContext context);
    public static void clearContext();
}

• 인스턴스를 생성하지 않고도 바로 사용할 수 있는 정적(static) 유틸리티 클래스
• ThreadLocal을 이용해, 각 요청(스레드)마다 독립적인 인증 정보를 저장

사용 흐름 (인증 과정)

1. 로그인하거나 JWT 검증이 성공하면
2. Authentication 객체를 생성 (UsernamePasswordAuthenticationToken)
3. SecurityContextHolder.getContext().setAuthentication(auth) 호출
4. 현재 요청 스레드의 SecurityContext에 인증 정보를 저장
5. 이후 컨트롤러나 서비스에서 SecurityContextHolder.getContext().getAuthentication()으로 정보 꺼냄

주요 메서드

• getContext() : 현재 요청의 인증 정보 가져오기
• setContext(SecurityContext) : 인증 정보 저장
• clearContext() : 인증 정보 제거 (로그아웃 등)

💚 SecurityContext

• Spring Security에서 현재 사용자의 인증 정보를 담는 인터페이스

누가 로그인했는지(Authentication) 어떤 권한이 있는지 등의 정보를 보관하는 보안 컨텍스트 객체

// 내부에는 단 하나의 필드만 존재 
public interface SecurityContext {
    Authentication getAuthentication();
    void setAuthentication(Authentication authentication);
}

// 구현체
public class SecurityContextImpl implements SecurityContext, Serializable {
    private Authentication authentication;

    public SecurityContextImpl() {}

    public SecurityContextImpl(Authentication authentication) {
        this.authentication = authentication;
    }

    @Override
    public Authentication getAuthentication() {
        return this.authentication;
    }

    @Override
    public void setAuthentication(Authentication authentication) {
        this.authentication = authentication;
    }
}

// 인증이 완료되면
Authentication auth = new UsernamePasswordAuthenticationToken("user", null, 권한);
SecurityContext context = SecurityContextHolder.createEmptyContext(); // 빈 컨텍스트 생성
context.setAuthentication(auth); // 인증 정보 주입
SecurityContextHolder.setContext(context); // SecurityContextHolder에 저장

인증이 완료되면 언제든 SecurityContextHolder.getContext().getAuthentication() 로 사용자 정보를 꺼낼 수 있다.

💚 Authentication

현재 사용자가 누구인지, 인증되었는지, 어떤 권한이 있는지를 나타내는 인터페이스

Spring Security에서는 모든 인증 정보를 Authentication 객체 하나에 담는다.
로그인했는지 여부, 사용자명, 비밀번호, 권한, 인증 상태 등

public interface Authentication extends Principal, Serializable {
    Collection<? extends GrantedAuthority> getAuthorities(); // 권한 목록
    Object getCredentials();          // 비밀번호 등 인증 수단
    Object getDetails();              // 요청 관련 추가 정보 (IP, 세션 등)
    Object getPrincipal();            // 사용자 정보
    boolean isAuthenticated();        // 인증 여부
    void setAuthenticated(boolean isAuthenticated) throws IllegalArgumentException;
}

메서드	설명	예시
getPrincipal()	사용자 주체 정보	보통 username 또는 UserDetails 객체
getCredentials()	인증 수단	비밀번호 또는 null (JWT 사용 시)
getAuthorities()	권한 목록	ROLE_USER, ROLE_ADMIN 등
isAuthenticated()	인증 여부	로그인 성공 후 true
getDetails()	세부 정보	IP, 세션 등 (옵션)

대부분 사용하는 구현체

구현체	용도
UsernamePasswordAuthenticationToken	가장 일반적인 인증 객체 (폼 로그인, JWT 등)
AnonymousAuthenticationToken	인증되지 않은 사용자 (익명 사용자 처리용)

UsernamePasswordAuthenticationToken authentication =
    new UsernamePasswordAuthenticationToken(
        "user123",                          // principal
        null,                               // credentials (JWT라 null)
        List.of(new SimpleGrantedAuthority("ROLE_USER")) // 권한
    );

authentication.setAuthenticated(true);

// 후에 저장되는 Authentication 객체
SecurityContextHolder.getContext().setAuthentication(authentication);

컨트롤러와 서비스에서 사용 예시

Authentication auth = SecurityContextHolder.getContext().getAuthentication();
String username = auth.getName();  // 또는 getPrincipal()

// 컨트롤러에서 바로 주입 가능
@GetMapping("/me")
public ResponseEntity<?> getMyInfo(Authentication auth){
	return ResponseEntity.ok(auth.getName());
}

💚 인증 정보 계층별 책임

계층	클래스	책임
1️⃣ 사용자 정보	Authentication	사용자 ID, 인증 여부, 권한 등 실제 인증 정보
2️⃣ 보안 컨텍스트	SecurityContext	현재 요청의 인증 상태를 담고 있음 (Authentication 객체 1개만 보관)
3️⃣ 요청 스레드 저장소	SecurityContextHolder	현재 요청(스레드)의 SecurityContext를 저장/관리 (정적 ThreadLocal 사용)

💙 @EnableMethodSecurity

메소드 단위에서 @PreAuthorize, @PostAuthorize 같은 어노테이션을 사용하도록 메소드 보안 활성화

💙 Spring Security + JWT 인증 흐름

 클라이언트 요청 (ex. /user/profile)
       ↓
 1. Spring Security Filter Chain 시작
       ↓
 2. JwtFilter 실행
    - Authorization 헤더에서 토큰 추출
    - 토큰 유효성 검증 (JwtUtil)
    - 사용자 정보(username, role 등) 추출
    - Authentication 객체 생성
    - SecurityContextHolder에 저장
       ↓
 3. 다음 필터들 (Spring 내부 인증/인가 필터들)
    - SecurityContextHolder에 Authentication 있으면
      인증된 사용자로 간주
       ↓
 4. 컨트롤러 도달 (@PreAuthorize 등도 적용 가능)
       ↓
 5. 요청 처리 및 응답 반환

요청 흐름도

사용자가 /user/profile 요청 (Authorization: Bearer abc.def.ghi)
                    ↓
[SecurityFilterChain] (filterChain()에서 구성됨)
                    ↓
[JwtFilter]
    - Authorization 헤더에서 토큰 꺼냄
    - 유효한 토큰인지 검사 (jwtUtil.validateToken)
    - 토큰에서 username, role 추출
    - 인증 객체 생성해서 SecurityContextHolder에 저장
                    ↓
[UsernamePasswordAuthenticationFilter] 등 다음 필터들
    - SecurityContextHolder에 인증 정보가 있으므로 통과
                    ↓
[Controller (@GetMapping("/user/profile"))]
    - ROLE_USER or ROLE_ADMIN 확인 후 요청 처리
                    ↓
[응답 반환]