[Security] JWT(JSON Web Token)

📌 개인적인 공간으로 공부를 기록하고 복습하기 위해 사용하는 블로그입니다.
정확하지 않은 정보가 있을 수 있으니 참고바랍니다 :😸
[틀린 내용은 댓글로 남겨주시면 복받으실거에요]

JWT(JSON Web Token)

토큰 기반 자격 증명

세션기반 자격 증명

세션 기반 자격 증명 방식은 서버 측에 인증된 사용자의 정보를 세션 형태로 세션 저장소에 저장하는 방식이다.

• 세션 기반 자격 증명의 특징
  • 세션은 인증된 사용자 정보를 서버 측 세션 저장소에서 관리한다.
  • 생성된 사용자 세션의 고유 ID인 세션 ID는 클라이언트의 쿠키에 저장되어 request 전송 시, 인증된 사용자인지를 증명하는 수단으로 사용된다.
  • 세션 ID만 클라이언트 쪽에서 사용하므로 상대적으로 적은 네트워크 트래픽을 사용한다.
  • 서버 측에서 세션 정보를 관리하므로 보안성 측면에서 조금 더 유리하다.
  • 서버의 확장성 면에서는 세션 불일치 문제가 발생할 가능성이 높다.
  • 세션 데이터가 많아지면 질수록 서버의 부담이 가중될 수 있다.
  • SSR(Server Side Rendering) 방식의 애플리케이션에 적합한 방식이다

토큰기반 자격 증명

토큰 기반 자격 증명 방식은 인증된 사용자의 정보를 토큰에 저장하고, 접근 권한을 부여해 접근 권한이 부여된 특정 리소스에만 접근할 수 있게 하는 방식이다.

• 토큰 기반 자격 증명의 특징
  • 토큰에 포함된 인증된 사용자 정보는 서버 측에서 별도의 관리를 하지 않는다.
  • 생성된 토큰을 헤더에 포함해 request 전송 시, 인증된 사용자인지를 증명하는 수단으로 사용된다.
  • 토큰 내에 인증된 사용자 정보 등을 포함하고 있으므로 세션에 비해 상대적으로 많은 네트워크 트래픽을 사용한다.
  • 기본적으로 서버 측에서 토큰을 관리하지 않으므로 보안성 측면에서 조금 더 불리하다.
  • 인증된 사용자 request의 상태를 유지할 필요가 없기 때문에 서버의 확장성 면에서 유리하고, 세션 불일치 같은 문제가 발생하지 않는다.
  • 토큰에 포함되는 사용자 정보는 토큰의 특성상 암호화가 되지 않기 때문에 공격자에게 토큰이 탈취될 경우, 사용자 정보를 그대로 제공하는 셈이 되므로 민감한 정보는 토큰에 포함하지 말아야 한다.
  • 기본적으로 토큰이 만료되기 전까지는 토큰을 무효화시킬 수 없다.
  • CSR(Client Side Rendering) 방식의 애플리케이션에 적합한 방식이다

JWT(JSON Web Token)

JWT는 데이터를 안전하고 간결하게 전송하기 위해 고안된 인터넷 표준 인증 방식으로써 토큰 인증 방식에서 가장 범용적으로 사용되며 JSON 포맷의 토큰 정보를 인코딩 후, 인코딩 된 토큰 정보를 Secret Key로 서명(Sign)한 메시지를 Web Token으로써 인증 과정에 사용

JWT 공식 사이트 : https://jwt.io/

JWT의 종류

JWT는 보통 다음과 같이 두 가지 종류의 토큰을 사용자의 자격 증명에 이용한다 ⇒ Access Token & Refresh Token

1. 액세스 토큰(Access Token)
   • 보호된 정보들(사용자의 이메일, 연락처, 사진 등)에 접근할 수 있는 권한 부여에 사용
   • 클라이언트가 처음 인증을 받게 될 때(로그인 시), Access Token과 Refresh Token 두 가지를 다 받지만, 실제로 권한을 얻는 데 사용하는 토큰은 Access Token
   • 주요 권한을 가지고 있기 때문에 Access Token에는 비교적 짧은 유효 기간을 주어 탈취되더라도 오랫동안 사용할 수 없도록 한다. ⇒ Access Token의 유효기간이 만료된다면 Refresh Token을 사용하여 새로운 Access Token을 발급받는다. 이때, 사용자는 다시 로그인 인증을 할 필요가 없다.
2. 리프레시 토큰(Refresh Token)
   • 액세스 토큰을 재발급받기 위한 정보만 담고 있음.
   • Access Token의 유효기간이 만료된다면 Refresh Token을 사용하여
   • 리프레쉬토큰은 유효기간이 길기 때문에 탈취당하면 문제가 된다. 그렇기 때문에 리프레쉬토큰을 일회용으로 만든다.
   • 즉 상태를 가지진 않지만. 액세스 토큰이 만료되서 리프레시에서 액세스토큰을 요청 할 때 리프레시 토큰도 함께 재발행 한다.
   • 사용자의 편의보다 정보를 지키는 것이 더 중요한 웹 애플리케이션은 Refresh Token을 사용하지 않는 곳이 많다.

JWT 구조

JWT는 위 그림과 같이 .으로 나누어진 세 부분이 존재한다.

1. Header
   • Header는 이것이 어떤 종류의 토큰인지(지금의 경우엔 JWT), 어떤 알고리즘으로 Sign할지 정의한다.

   • JSON Web Token이라는 이름에 걸맞게 JSON 포맷 형태로 정의되어 있다.

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

   • 단방향 암호화

   

   서버에서는 사용자의 정보를 시그니처로 확인한다 → 시그니처가 검증의 대상이다 ,

   JWT의 헤더와 플레이 로드는 해시함수 검증과정에서 걸러짐

   두가지 데이터를 복호화하더라도 보통 클라이언트에서 서버로 보낼때 헤더에 담아서 보

2. Payload

    {
      "sub": "someInformation",
      "name": "phillip",
      "iat": 151623391
    }
   

   • Payload에는 서버에서 활용할 수 있는 사용자의 정보가 담겨 있다.
   • 어떤 정보에 접근 가능한지에 대한 권한을 담을 수도 있고, 사용자의 이름 등 필요한 데이터를 담을 수 있다.
   • Payload는 다음으로 설명할 Signature를 통해 유효성이 검증될 정보이긴 하지만, 민감한 정보는 담지 않는 것이 좋다. (손쉽게 코딩 할 수 있기 때문)
   • 첫 번째 부분과 마찬가지로, 위 JSON 객체를 base64로 인코딩하면 JWT의 두 번째 블록이 완성됩니다.
3. Signature
   • base64로 인코딩 된 첫 번째, 그리고 두 번째 부분이 완성되었다면, Signature에서는 원하는 비밀 키(Secret Key)와 Header에서 지정한 알고리즘을 사용하여 Header와 Payload에 대해서 단방향 암호화를 수행한다.
   • 이렇게 암호화된 메시지는 토큰의 위변조 유무를 검증하는 데 사용된다.

   • 예를 들어, 만약 HMAC SHA256 알고리즘(암호화 방법 중 하나)을 사용한다면 Signature는 아래와 같은 방식으로 생성됨

       HMACSHA256(base64UrlEncode(header) + '.' + base64UrlEncode(payload), secret);
     

JWT 사용 예시

JWT는 권한 부여에 매우 유용합니다.

새로 다운로드한 A라는 앱이 Gmail과 연동되어 이메일을 읽어와야 한다고 생각해 봅시다.

이 경우, 사용자는

1. Gmail 인증서버에 로그인 정보(아이디, 비밀번호)를 제공합니다.
2. 인증에 성공할 경우, JWT를 발급받습니다.
3. A 앱은 JWT를 사용해 해당 사용자의 이메일을 읽거나 사용할 수 있습니다.

토큰 기반 인증 절차

1. 클라이언트가 서버에 아이디/비밀번호를 담아 로그인 요청을 보냅니다.
2. 아이디/비밀번호가 일치하는지 확인하고, 클라이언트에게 보낼 암호화된 토큰을 생성합니다.
   • Access Token과 Refresh Token을 모두 생성합니다.
     • 토큰에 담길 정보(Payload)는 사용자를 식별할 정보, 사용자의 권한 정보 등이 될 수 있습니다.
     • Refresh Token 이용해 새로운 Access Token을 생성할 것이므로 두 종류의 토큰이 같은 정보를 담을 필요는 없습니다.
3. 토큰을 클라이언트에게 전송하면, 클라이언트는 토큰을 저장합니다.
   • 저장하는 위치는 Local Storage, Session Storage, Cookie 등이 될 수 있습니다.
4. 클라이언트가 HTTP Header(Authorization Header) 또는 쿠키에 토큰을 담아 request를 전송합니다.
   • Bearer authentication을 이용합니다. 참고 링크1(요약), 링크2(상세)
5. 서버는 토큰을 검증하여 “아 우리가 발급해 준 토큰이 맞네!”라는 판단이 될 경우, 클라이언트의 요청을 처리한 후 응답을 보내준다.

장단점

JWT를 통한 인증의 장점

1. 상태를 유지하지 않고(Stateless), 확장에 용이한(Scalable) 애플리케이션을 구현하기 용이하다.
   • 서버는 클라이언트에 대한 정보를 저장할 필요 없습니다. (토큰이 정상적으로 검증되는지만 판단합니다)
   • 클라이언트는 request를 전송할 때마다 토큰을 헤더에 포함시키면 된다
     • 여러 대의 서버를 이용한 서비스라면 하나의 토큰으로 여러 서버에서 인증이 가능하기 때문에 JWT를 사용하는 것이 효과적이다.

     만약에 세션 방식이라면 모든 서버가 해당 사용자의 세션 정보를 공유하고 있어야 한다.

2. 클라이언트가 request를 전송할 때마다 자격 증명 정보를 전송할 필요가 없다.
   • HTTP Basic 같은 인증 방식은 request를 전송할 때마다 자격 증명 정보를 포함해야 하지만 JWT의 경우 토큰이 만료되기 전까지는 한 번의 인증만 수행하면 된다.
3. 인증을 담당하는 시스템을 다른 플랫폼으로 분리하는 것이 용이하다
   • 사용자의 자격 증명 정보를 직접 관리하지 않고, Github, Google 등의 다른 플랫폼의 자격 증명 정보로 인증하는 것이 가능
   • 토큰 생성용 서버를 만들거나, 다른 회사에서 토큰 관련 작업을 맡기는 것 등 다양한 활용이 가능
4. 권한 부여에 용이하다
   • 토큰의 Payload(내용물) 안에 해당 사용자의 권한 정보를 포함하는 것이 용이하다

JWT를 통한 인증의 단점

1. Payload는 디코딩이 용이하다
   • Payload는 base64로 인코딩 되기 때문에 토큰을 탈취하여 Payload를 디코딩하면 토큰 생성 시 저장한 데이터를 확인할 수 있습니다. 따라서 Payload에는 민감한 정보를 포함하지 않아야 한다.
2. 토큰의 길이가 길어지면 네트워크에 부하를 줄 수 있다

   • 토큰에 저장하는 정보의 양이 많아질수록 토큰의 길이는 길어진다.

     따라서 request를 전송할 때마다 길이가 긴 토큰을 함께 전송하면 네트워크에 부하를 줄 수 있다.

3. 토큰은 자동으로 삭제되지 않는다.
   • 즉 한 번 생성된 토큰은 자동으로 삭제되지 않기 때문에 토큰 만료 시간을 반드시 추가해야 한다.
   • 또한 토큰이 탈취된 경우 토큰의 기한이 만료될 때까지 토큰 탈취자가 해당 토큰을 정상적으로 이용할 수 있으므로 만료 시간을 너무 길게 설정하지 않아야 한다.

커피 주문애플리케이션에 JWT적용

사전작업 (의존성추가, 비밀번호관련 필드 추가)

1. 의존라이브러리 추가

	// Spring Security를 적용하기 위해 spring-boot-starter-security를 추가
	implementation 'org.springframework.boot:spring-boot-starter-security'

  // (2) JWT 기능을 위한 jjwt 라이브러리 추가
	implementation 'io.jsonwebtoken:jjwt-api:0.11.5'
	runtimeOnly 'io.jsonwebtoken:jjwt-impl:0.11.5'
	runtimeOnly	'io.jsonwebtoken:jjwt-jackson:0.11.5'

2. JWT 적용 전 Spring Security를 이용해서 최소한의 보안구성

package com.springboot.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.Customizer;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.crypto.factory.PasswordEncoderFactories;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.security.web.SecurityFilterChain;
import org.springframework.web.cors.CorsConfiguration;
import org.springframework.web.cors.CorsConfigurationSource;
import org.springframework.web.cors.UrlBasedCorsConfigurationSource;

import java.util.Arrays;

import static org.springframework.security.config.Customizer.withDefaults;

@Configuration
public class SecurityConfiguration {

    @Bean
    public SecurityFilterChain filterChain(HttpSecurity http)throws Exception{
        http
                .headers().frameOptions().sameOrigin()
                //동일 출처로부터 들어오는 request만 페이지 렌더링을 허용
                .and()
                .csrf().disable() //배포할 때만 변경하면 됨.
                .cors(withDefaults()) //corsConfigurationSource라는 이름으로 등록된 Bean을 이용
                //CORS를 처리하는 가장 쉬운 방법은 CorsFilter를 사용하는 것인데 
                // CorsConfigurationSource Bean을 제공함으로써 CorsFilter를 적용할 수 있다.
                .formLogin().disable() //폼로그인 사용하지 않겟다.
                .httpBasic().disable()
                .authorizeHttpRequests(authorize -> authorize.anyRequest().permitAll());
                //인증인가 후 변경예정
        return http.build();
    }

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

    //Cors설정 추가, corsConfigurationSource를 빈으로 동록
    @Bean
    CorsConfigurationSource corsConfigurationSource(){
        CorsConfiguration configuration = new CorsConfiguration();
        configuration.setAllowedOrigins(Arrays.asList("*"));
            //모든 출처(Origin)에 대해 스크립트 기반의 HTTP 통신을 허용하도록 설정
        configuration.setAllowedMethods(Arrays.asList("GET","POST","PATCH","DELETE"));
            //파라미터로 지정한 HTTP Method에 대한 HTTP 통신을 허용
        UrlBasedCorsConfigurationSource source  = new UrlBasedCorsConfigurationSource();
        source.registerCorsConfiguration("/**",configuration);
       return source;

    }
}

Password 필드추가

1. MemberDto.Post

     @NotBlank
            private String password;
   

2. Member -password, Authorize 추가

    @Column(length = 100, nullable = false)
        private String password;
   
    @ElementCollection(fetch = FetchType.EAGER)
        private List<String>role = new ArrayList<>();
   

3. MemberService

    @Transactional
    @Service
    public class MemberService {
        private final MemberRepository memberRepository;
        private final ApplicationEventPublisher publisher;
           
        // 추가
        private final PasswordEncoder passwordEncoder;
        private final JwtAuthorityUtils jwtAuthorityUtils;
           
        public MemberService(MemberRepository memberRepository,
                             ApplicationEventPublisher publisher, PasswordEncoder passwordEncoder, JwtAuthorityUtils jwtAuthorityUtils) {
            this.memberRepository = memberRepository;
            this.publisher = publisher;
             
          //추가
            this.passwordEncoder = passwordEncoder;
            this.jwtAuthorityUtils = jwtAuthorityUtils;
        }
       
    public Member createMember(Member member) {
            verifyExistsEmail(member.getEmail());
       
            //패스워드 암호화 필요 - 단방향 암호
            String encrypedPassword =  passwordEncoder.encode(member.getPassword());
            member.setPhone(encrypedPassword);
       
            //DB에 UserRoles 저장
            List<String> roles = jwtAuthorityUtils.createRoles(member.getEmail());
            member.setRoles(roles);
       
            Member savedMember = memberRepository.save(member);
       
            
            publisher.publishEvent(new MemberRegistrationApplicationEvent(this, savedMember));
            return savedMember;
        }
   

멱등성을 가지는 것. (서버에 동일한 요청을 하는지를 봐야 함.= GET,POST,DELETE

1. JwtAuthorityUtils 클래스 생성

    package com.springboot.auth.utils;
       
    import org.springframework.beans.factory.annotation.Value;
    import org.springframework.security.core.authority.AuthorityUtils;
    import org.springframework.security.core.GrantedAuthority;
    import org.springframework.security.core.authority.SimpleGrantedAuthority;
    import org.springframework.stereotype.Component;
    import java.util.List;
    import java.util.stream.Collectors;
       
    @Component
    public class JwtAuthorityUtils {
        @Value("${mail.address.admin}")
        private String adminMailAddress;
       
        private final List<GrantedAuthority> ADMIN_ROLES
                = AuthorityUtils.createAuthorityList("ROLE_ADMIN","ROLEUSER");
       
        private final List<GrantedAuthority>USER_ROLES
                = AuthorityUtils.createAuthorityList("ROLE_USER");
        private final List<String> ADMIN_ROLES_STRING = List.of("ADMIN","USER");
        private final List<String> USER_ROLES_STRING = List.of("USER");
       
        public List<GrantedAuthority> createAutrorities(String email){
            if(email.equals(adminMailAddress)){
                return ADMIN_ROLES;
            }
            return USER_ROLES;
        }
       
        public List<GrantedAuthority>createAuthority(List<String>roles){
            return roles.stream()
                    .map(role-> new SimpleGrantedAuthority("ROLE_"+role))
                    .collect(Collectors.toList());
        }
        public List<String>createRoles(String email){
            if(email.equals(adminMailAddress)){
                return ADMIN_ROLES_STRING;
            }
            return USER_ROLES_STRING;
        }
    }
       
   

로그인 인증

사용자의 Username(이메일 주소)과 Password로 로그인 인증에 성공하면 로그인 인증에 성공한 사용자에게 JWT를 생성 및 발급하기

사용자의 로그인 인증 성공 후, JWT가 클라이언트에게 전달되는 과정

1. 클라이언트가 서버 측에 로그인 인증 요청(Username/Password를 서버 측에 전송)
2. 로그인 인증을 담당하는 Security Filter(JwtAuthenticationFilter)가 클라이언트의 로그인 인증 정보 수신
3. Security Filter가 수신한 로그인 인증 정보를 AuthenticationManager에게 전달해 인증 처리를 위임
4. AuthenticationManager가 Custom UserDetailsService(MemberDetailsService)에게 사용자의 UserDetails 조회를 위임
5. Custom UserDetailsService(MemberDetailsService)가 사용자의 크리덴셜을 DB에서 조회한 후, AuthenticationManager에게 사용자의 UserDetails를 전달
6. AuthenticationManager가 로그인 인증 정보와 UserDetails의 정보를 비교해 인증 처리
7. JWT 생성 후, 클라이언트의 응답으로 전달

4번과 6번은 Spring Security의 AuthenticationManager가 대신 처리해줌

1️⃣ Custom UserDetailsService 구현

package com.springboot.auth.userDetails;

import com.springboot.auth.utils.JwtAuthorityUtils;
import com.springboot.exception.BusinessLogicException;
import com.springboot.exception.ExceptionCode;
import com.springboot.member.entity.Member;
import com.springboot.member.repository.MemberRepository;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.core.userdetails.UsernameNotFoundException;

import java.util.Collection;
import java.util.Optional;

public class MemberDetailsService implements UserDetailsService {
    private final MemberRepository memberRepository;
    private final JwtAuthorityUtils authorityUtils;

    public MemberDetailsService(MemberRepository memberRepository, JwtAuthorityUtils authorityUtils) {
        this.memberRepository = memberRepository;
        this.authorityUtils = authorityUtils;
    }

    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
        //DB에서 조회
        Optional<Member> optionalMember = memberRepository.findByEmail(username);
        Member findMember = optionalMember.orElseThrow(()-> new BusinessLogicException(ExceptionCode.MEMBER_NOT_FOUND));
        //Member는 DB에서 가져온 것이므로 - 암호화 되어있다.
        return new MemberDetails(findMember);
    }

    //Member를 확장
    private final class MemberDetails extends Member implements UserDetails{
        //MemberDetails는 생성자 -> 이건 바로 위의 반환된 값 
        // = DB에서 가져온 것.  = 암호화 되어있음.
        
        MemberDetails(Member member){
            setMemberId(member.getMemberId());
            setEmail(member.getEmail());
            setPassword(member.getPassword());
            setRoles(member.getRoles());
        }

        @Override
        public Collection<? extends GrantedAuthority> getAuthorities() {
            return authorityUtils.createAuthority(this.getRoles());
        }

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

        @Override
        public boolean isAccountNonExpired() {
            return true;  //false에서 수정
        }

        @Override
        public boolean isAccountNonLocked() {
            return true; //false에서 수정
        }

        @Override
        public boolean isCredentialsNonExpired() {
            return true; //false에서 수정
        }

        @Override
        public boolean isEnabled() {
            return true; //false에서 수정
        }
    }
}

2️⃣ 로그인 인증 정보 역직렬화(Deserialization)를 위한 LoginDTO 클래스 생성

클라이언트가 전송한 Username/Password 정보를 Security Filter에서 사용할 수 있도록 역직렬화(Deserialization) 하기 위한 DTO 클래스이다.

package com.springboot.auth.dto;

import lombok.Getter;

@Getter //dto에는 Getter 필수.
public class LoginDto {
    private String username;
    private String password;
}

3️⃣ JWT를 생성하는 JwtTokenizer 구현

1. JwtTokenizer

    package com.springboot.auth.jwt;
       
    import lombok.Getter;
    import org.springframework.beans.factory.annotation.Value;
       
    public class JwtTokenizer {
        @Getter
        @Value("${jwt.key}") //yml에 저장 필수
        private String secretKey;
        @Getter
        @Value("${jwt.access-token-expiration-minute}") //yml에 저장 필수
        private int accessTokenExpirationMinutes;
        @Getter
        @Value("${jwt.refresh-token-expiration-minute}") //yml에 저장 필수
        private int refreshTokenExpirationMinutes;
       
    }
       
   

2. application.yml

   • ${JWT_SECRET_KEY}는 단순한 문자열이 아니라 OS의 시스템 환경 변수의 값을 읽어오는 일종의 표현식

     

3. 시스템 환경변수 편집 (시스템환경변수편집- 환경변수 - 시스템변수 추가)

   • JWT의 서명에 사용되는 Secret Key 정보는 민감한(sensitive) 정보이므로 시스템 환경 변수의 변수로 등록

     

4️⃣ 로그인 인증 요청을 처리하는 Custom Security Filter 구현

JwtAuthenticationFilter

//UsernamePasswordAuthenticationfilter를 교체하는 것.
public class JwtAuthenticationFilter extends UsernamePasswordAuthenticationFilter {
    //폼 로그인 방식에서 사용하는 디폴트 Security Filter로써,
    //폼 로그인이 아니더라도 Username/Password 기반의 인증을 처리하기 위해
    // UsernamePasswordAuthenticationFilter를 확장해서 구현

    private final AuthenticationManager authenticationManager;
    // 로그인 인증 정보(Username/Password)를 전달받아 UserDetailsService와 인터랙션 한 뒤 인증 여부를 판단
    private final JwtTokenizer jwtTokenizer;
    //클라이언트가 인증에 성공할 경우, JWT를 생성 및 발급

    public JwtAuthenticationFilter(AuthenticationManager authenticationManager, JwtTokenizer jwtTokenizer) {
        this.authenticationManager = authenticationManager;
        this.jwtTokenizer = jwtTokenizer;
    }

    @SneakyThrows //try-catch를 대체
    @Override
    public Authentication attemptAuthentication(HttpServletRequest request, HttpServletResponse response){
        //클라이언트에서 전송한 Username과 Password를 DTO 클래스로 역직렬화(Deserialization) 하기 위해 ObjectMapper 인스턴스를 생성
        ObjectMapper objectMapper = new ObjectMapper();
        LoginDto loginDto = objectMapper.readValue(request.getInputStream(), LoginDto.class);
        //ServletInputStream을 LoginDto 클래스의 객체로 역직렬화한다.

        // token 만드는 이유 UsernamePasswordAuthenticationToken 을 대체하는 것, 구현체도 실제로 만들어져있음
        UsernamePasswordAuthenticationToken authenticationToken
                = new UsernamePasswordAuthenticationToken(loginDto.getUsername(),loginDto.getPassword());

        return authenticationManager.authenticate(authenticationToken);

    }

    protected void successfulAuthentication(HttpServletRequest request,
                                            HttpServletResponse response,
                                            FilterChain chain,
                                            Authentication authentication) throws ServletException, IOException {
        Member member = (Member) authentication.getPrincipal();

        //token 만들기
        String accessToken= delegateAceessToken(member);
        String refreshToken = delegateRefreshToken(member);
        response.setHeader("Authorization", "Bearer " + accessToken);
        response.setHeader("Refresh", refreshToken);
        this.getSuccessHandler().onAuthenticationSuccess(request,response,authentication);
    }

    protected String delegateAceessToken(Member member){
        Map<String,Object> claims = new HashMap<>();
        claims.put("username",member.getEmail());
        claims.put("roles", member.getRoles());
                //token안에 절대 비밀번호 넣지않음, playload 디코딩은 엄청쉽다.
        String subject = member.getEmail();
        Date expiration = jwtTokenizer.getTokenExpiration(jwtTokenizer.getAccessTokenExpirationMinutes());
        String base64EncodedSecretKey = jwtTokenizer.encodeBase64SecretKey(jwtTokenizer.getSecretKey());
        String accessToken = jwtTokenizer.generateAccessToken(claims, subject, expiration, base64EncodedSecretKey);
        return accessToken;

        //민감한 정보는 절대 평문화 하면 안됨.
        //스프링에서 인증인가는 무조건 security사용
    }

    protected String delegateRefreshToken(Member member) {

        String subject = member.getEmail();
        Date expiration = jwtTokenizer.getTokenExpiration(jwtTokenizer.getRefreshTokenExpirationMinutes());
        String base64EncodedSecretKey = jwtTokenizer.encodeBase64SecretKey(jwtTokenizer.getSecretKey());
        String refreshToken = jwtTokenizer.generateRefreshToken(subject, expiration, base64EncodedSecretKey);
        return refreshToken;
    }
    //실패했을땐 자동으로 등록 된다.
    //성공했을때는 성공하고 나서 수행할 작업이 필요하기 때문에 명식적으로 넣어주어야

}

5️⃣ Custom Filter 추가를 위한 SecurityConfiguration 설정 추가

SecurityConfiguration

@Configuration
public class SecurityConfiguration {
    private final JwtTokenizer jwtTokenizer;

    public SecurityConfiguration(JwtTokenizer jwtTokenizer) {
        this.jwtTokenizer = jwtTokenizer;
    }

    @Bean
    public SecurityFilterChain filterChain(HttpSecurity http)throws Exception{
        http
                .headers().frameOptions().sameOrigin()
                .and()
                .csrf().disable() //배포할 때만 변경하면 됨.
                .cors(withDefaults())
                .sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS)
                .and()
                .formLogin().disable() //폼로그인 사용하지 않겟다.
                .httpBasic().disable()
                .apply(new CustomFilterConfigurer())
                .and()
	              .authorizeHttpRequests(authorize -> authorize.anyRequest().permitAll());
         
        return http.build();

    }

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

    //Cors설정 추가, corsConfigurationSource를 빈으로 동록
    @Bean
    CorsConfigurationSource corsConfigurationSource(){
        CorsConfiguration configuration = new CorsConfiguration();
        configuration.setAllowedOrigins(Arrays.asList("*"));
        configuration.setAllowedMethods(Arrays.asList("GET","POST","PATCH","DELETE"));
        UrlBasedCorsConfigurationSource source  = new UrlBasedCorsConfigurationSource();
        source.registerCorsConfiguration("/**",configuration);
       return source;
    }

    public class CustomFilterConfigurer extends AbstractHttpConfigurer<CustomFilterConfigurer,HttpSecurity>{
            //AbstractHttpConfigurer를 상속해서 Custom Configurer를 구현
            //AbstractHttpConfigurer를 상속하는 타입과 HttpSecurityBuilder를 상속하는 타입을 제너릭 타입으로 지정할 수 있다.
        @Override  //configure() 메서드를 오버라이드해서 Configuration을 커스터마이징
        public void configure(HttpSecurity builder){
            AuthenticationManager authenticationManager = builder.getSharedObject(AuthenticationManager.class);
            //getSharedObject()를 통해서 Spring Security의 설정을 구성하는 SecurityConfigurer 간에 공유되는 객체를 얻을 수 있다.

            JwtAuthenticationFilter jwtAuthenticationFilter = new JwtAuthenticationFilter(authenticationManager, jwtTokenizer);
            //  JwtAuthenticationFilter에서 사용되는 AuthenticationManager와 JwtTokenizer를 DI해준다.

            jwtAuthenticationFilter.setFilterProcessesUrl("/v11/auth/login"); //없을때는 기본적으로 로그인이 적용됨 ("/login)

            builder.addFilter(jwtAuthenticationFilter);
            // addFilter() 메서드를 통해 JwtAuthenticationFilter를 Spring Security Filter Chain에 추가
        }
    }
}

온전히 이해하기 힘들기 때문에 이렇게 쓰는 구나 하고 외우기….?

로그인 시도

1. 회원가입

   

2. 로그인

   

3. 비밀번호 잘못 입력시 에러 발생

   HttpStatus.UNAUTHORIZED(401) 상태 코드는 인증에 실패할 경우 전달할 수 있는 HTTP status

   → 추가 개선 필요

로그인 인증 성공 및 실패에 따른 추가 처리

1️⃣ AuthenticationSuccessHandler 구현

@Slf4j
public class MemberAuthenticationSuccessHandler implements AuthenticationSuccessHandler {
    @Override
    public void onAuthenticationSuccess(HttpServletRequest request, HttpServletResponse response, Authentication authentication) throws IOException{
        log.info("# Authenticated successfully!");
    }
}

2️⃣ AuthenticationFailureHandler 구현

//component 없는건 스프링 컨테이너가 잡아주는 것이 아니기 때문에,
//인증을 담당하는 JwtAuthenticationFilter에 이 객체를 추가해주어야 함.
@Slf4j
public class MemberAuthenticationFailureHandler implements AuthenticationFailureHandler {
    @Override
    public void onAuthenticationFailure(HttpServletRequest request, HttpServletResponse response, AuthenticationException exception) throws IOException, ServletException {
        //보통 로깅 기능 포함
        log.info("Authenticated failed");
        log.error("Authenticated failed", exception.getMessage());
        sendErrorResponse(response);

    }

    private void sendErrorResponse(HttpServletResponse response) throws IOException {
        Gson gson = new Gson();
        ErrorResponse errorResponse = ErrorResponse.of(HttpStatus.UNAUTHORIZED);
        //HttpStatus.UNAUTHORIZED 상태 코드를 전달
        response.setContentType(MediaType.APPLICATION_JSON_VALUE);
        // Content Type이 “application/json”이라는 것을 클라이언트에게 알려줄 수 있도록 MediaType.APPLICATION_JSON_VALUE를 HTTP Header에 추가
        response.setStatus(HttpStatus.UNAUTHORIZED.value());
        // response의 status가 401 임을 클라이언트에게 알려줄 수 있도록 HttpStatus.UNAUTHORIZED.value()을 HTTP Header에 추가
        
        response.getWriter().write(gson.toJson(errorResponse,ErrorResponse.class));
        //Gson을 이용해 ErrorResponse 객체를 JSON 포맷 문자열로 변환 후, 
        //출력 스트림을 생성
    }
}

3️⃣ AuthenticationSuccessHandler와 AuthenticationFailureHandler 추가

AuthenticationFailureHandler 인터페이스의 구현 클래스를 JwtAuthenticationFilter에 등록하면 로그인 인증 시, 두 핸들러를 사용할 수 있다.

  @Configuration
public class SecurityConfiguration {
    private final JwtTokenizer jwtTokenizer;

    public SecurityConfiguration(JwtTokenizer jwtTokenizer) {
        this.jwtTokenizer = jwtTokenizer;
    }
    
    ...
  
  public class CustomFilterConfigurer extends AbstractHttpConfigurer<CustomFilterConfigurer, HttpSecurity> {
        @Override
        public void configure(HttpSecurity builder) throws Exception {
            AuthenticationManager authenticationManager = builder.getSharedObject(AuthenticationManager.class);

            JwtAuthenticationFilter jwtAuthenticationFilter = new JwtAuthenticationFilter(authenticationManager, jwtTokenizer);
            jwtAuthenticationFilter.setFilterProcessesUrl("/v11/auth/login");
            jwtAuthenticationFilter.setAuthenticationSuccessHandler(new MemberAuthenticationSuccessHandler());  // (3) 추가
            jwtAuthenticationFilter.setAuthenticationFailureHandler(new MemberAuthenticationFailureHandler());  // (4) 추가
            builder.addFilter(jwtAuthenticationFilter);
        }
    }
}

AuthenticationSuccessHandler와 AuthenticationFailureHandler 인터페이스의 구현 클래스가 다른 Security Filter에서 사용이 된다면 ApplicationContext에 Bean으로 등록해서 DI 받는 게 맞다.

💡 하지만 일반적으로 인증을 위한 Security Filter마다 AuthenticationSuccessHandler와 AuthenticationFailureHandler의 구현 클래스를 각각 생성할 것이므로 new 키워드를 사용해서 객체를 생성해도 무방

4️⃣ AuthenticationSuccessHandler 호출

JwtAuthenticationFilter(AuthenticationSuccessHandler 호출 코드 추가)

public class JwtAuthenticationFilter extends UsernamePasswordAuthenticationFilter {
    ...
    ...

    @Override
    protected void successfulAuthentication(HttpServletRequest request,
                                            HttpServletResponse response,
                                            FilterChain chain,
                                            Authentication authResult) throws ServletException, IOException {
        Member member = (Member) authResult.getPrincipal();

        String accessToken = delegateAccessToken(member);
        String refreshToken = delegateRefreshToken(member);

        response.setHeader("Authorization", "Bearer " + accessToken);
        response.setHeader("Refresh", refreshToken);

        this.getSuccessHandler().onAuthenticationSuccess(request, response, authResult);  // (1) 추가
    }

    ...
    ...
}

자격증명 및 검증 구현

클라이언트 측에서 JWT를 이용해 자격 증명이 필요한 리소스에 대한 request 전송 시, request header를 통해 전달받은 JWT를 서버 측에서 검증하는 기능

1️⃣ JWT 검증 필터 구현

package com.springboot.auth.filter;

import com.springboot.auth.jwt.JwtTokenizer;
import com.springboot.auth.utils.JwtAuthorityUtils;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.security.core.userdetails.UsernameNotFoundException;
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.util.List;
import java.util.Map;

// OncePerRequestFilter를 확장해서 request 당 한 번만 실행되는 Security Filter를 구현할 수 있다.
//구현체라서 상속받아서 구현할 것. -토큰과 관련된 서비스, 권한을 가져와야 함
public class JwtVerifiedFilter extends OncePerRequestFilter {
    private final JwtTokenizer jwtTokenizer;
    private final JwtAuthorityUtils authorityUtils;

    public JwtVerifiedFilter(JwtTokenizer jwtTokenizer, JwtAuthorityUtils authorityUtils) {
        this.jwtTokenizer = jwtTokenizer;
        this.authorityUtils = authorityUtils;
    }

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

        Map<String,Object> claims = verifyJws(request);
          //SecurityContext안에 저장해주어야 함.
        setAuthenticationToContext(claims);
	        // Authentication 객체를 SecurityContext에 저장
        filterChain.doFilter(request,response);
	       // 다음(Next) Security Filter를 호출
    }

    @Override
    protected boolean shouldNotFilter(HttpServletRequest request){
    // 특정 조건에 부합하면(true이면) 해당 Filter의 동작을 수행하지 않고 
    // 다음 Filter로 건너 뛰도로 ㄱ해준다. 
        String authorization = request.getHeader("Athorization");
	        //Authorization header의 값을 얻은 후
        return authorization == null || !authorization.startsWith("Bearer");
	        //Authorization header의 값이 null이거나 
	        //Authorization header의 값이 “Bearer”로 시작하지 않는다면 해당 Filter의 동작을 수행하지 않도록 정의
			    // JWT가 Authorization header에 포함되지 않았다면 
			    // JWT 자격증명이 필요하지 않은 리소스에 대한 요청이라고 판단하고 
			    // 다음(Next) Filter로 처리를 넘기는 것
    
    }

    private Map<String, Object> verifyJws(HttpServletRequest request){
        String jws = request.getHeader("Authorization").replace("Bearer","");
        
        String bas64EncodedSecretKey =jwtTokenizer.encodeBase64SecretKey(jwtTokenizer.getSecretKey());
				// JWT 서명(Signature)을 검증하기 위한 Secret Key를 얻는다.
        Map<String,Object>claims = jwtTokenizer.getClaims(jws,bas64EncodedSecretKey).getBody();
        // JWT에서 Claims를 파싱 -> getClaims 안에서 검증까지 이루어지는 것.
        return claims;
    }

    private void setAuthenticationToContext(Map<String,Object>claims){
        String username = (String) claims.get("username");
        List<GrantedAuthority> authorities = authorityUtils.createAuthorities((List)claims.get("roles"));
        Authentication authentication = new UsernamePasswordAuthenticationToken(username,null,authorities);
                //password는 넣지 않는다.중요!!
        SecurityContextHolder.getContext().setAuthentication(authentication);

    }
}

• shouldNotFilter()
  • JWT가 Authorization header에 포함되지 않았다면 JWT 자격증명이 필요하지 않은 리소스에 대한 요청이라고 판단하고 다음(Next) Filter로 처리를 넘기는 것
  • 만일 JWT 자격 증명이 필요한 리소스 요청인데 실수로 JWT를 포함하지 않았다 하더라도 이 경우에는 Authentication이 정상적으로 SecurityContext에 저장되지 않은 상태이기 때문에 다른 Security Filter를 거쳐 결국 Exception을 던지게 될 것

2️⃣ SecurityConfiguration 설정 업데이트

• 세션 정책 설정 추가
• JwtVerificationFilter 추가

SecurityConfiguration

@Configuration
public class SecurityConfiguration {
    private final JwtTokenizer jwtTokenizer;
    private final JwtAuthorityUtils authorityUtils;

    public SecurityConfiguration(JwtTokenizer jwtTokenizer, JwtAuthorityUtils authorityUtils) {
        this.jwtTokenizer = jwtTokenizer;
        this.authorityUtils = authorityUtils;
    }

    @Bean
    public SecurityFilterChain filterChain(HttpSecurity http)throws Exception{
        http
                .headers().frameOptions().sameOrigin()
                .and()
                .csrf().disable() //배포할 때만 변경하면 됨.
                .cors(withDefaults())
                .sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS)
	               // 세션을 생성하지 않도록 설
                .and()
                .formLogin().disable() //폼로그인 사용하지 않겟다.
                .httpBasic().disable()
                .apply(new CustomFilterConfigurer())
                .and()
                .authorizeHttpRequests(authorize -> authorize.anyRequest().permitAll());
                //인증인가 후 변경예정

        return http.build();
    }

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

    //Cors설정 추가, corsConfigurationSource를 빈으로 동록
    @Bean
    CorsConfigurationSource corsConfigurationSource(){
        CorsConfiguration configuration = new CorsConfiguration();
        configuration.setAllowedOrigins(Arrays.asList("*"));
        configuration.setAllowedMethods(Arrays.asList("GET","POST","PATCH","DELETE"));
        UrlBasedCorsConfigurationSource source  = new UrlBasedCorsConfigurationSource();
        source.registerCorsConfiguration("/**",configuration);
       return source;
    }

    public class CustomFilterConfigurer extends AbstractHttpConfigurer<CustomFilterConfigurer,HttpSecurity>{
        @Override
        public void configure(HttpSecurity builder){
            AuthenticationManager authenticationManager = builder.getSharedObject(AuthenticationManager.class);

            JwtAuthenticationFilter jwtAuthenticationFilter = new JwtAuthenticationFilter(authenticationManager, jwtTokenizer);
            jwtAuthenticationFilter.setFilterProcessesUrl("/v11/auth/login"); //없을때는 기본적으로 로그인이 적용됨 ("/login)
            jwtAuthenticationFilter.setAuthenticationSuccessHandler(new MemberAuthenticationSuccessHandler());
            jwtAuthenticationFilter.setAuthenticationFailureHandler(new MemberAuthenticationFailureHandler());

            JwtVerifiedFilter jwtVerifiedFilter = new JwtVerifiedFilter(jwtTokenizer,authorityUtils);
            //JwtVerificationFilter의 인스턴스를 생성하면서 
            //JwtVerificationFilter에서 사용되는 객체들을 생성자로 DI를 해준다.

            builder.addFilter(jwtAuthenticationFilter)
                    .addFilterAfter(jwtVerifiedFilter,JwtVerifiedFilter.class);
                    //jwtAuthenticationFilter에서 로그인 인증에 성공한 후 발급받은 JWT가 클라이언트의 request header(Authorization 헤더)에 포함되어 있을 경우에만 동작
        }
    }
}

• SessionCreationPolicy의 설정 값
  • SessionCreationPolicy.ALWAYS : 항상 세션을 생성합니다.
  • SessionCreationPolicy.NEVER : 세션을 생성하지 않지만 만약에 이미 생성된 세션이 있다면 사용한다.
  • SessionCreationPolicy.IF_REQUIRED :필요한 경우에만 세션을 생성한다.
  • SessionCreationPolicy.STATELESS : 세션을 생성하지 않으며, SecurityContext 정보를 얻기 위해 결코 세션을 사용하지 않는다.

서버 측 리소스에 역할(Role) 기반 권한 적용

SecurityConfiguration

package com.springboot.config;
...

@Configuration
public class SecurityConfiguration {
    private final JwtTokenizer jwtTokenizer;
    private final JwtAuthorityUtils authorityUtils;

    public SecurityConfiguration(JwtTokenizer jwtTokenizer, JwtAuthorityUtils authorityUtils) {
        this.jwtTokenizer = jwtTokenizer;
        this.authorityUtils = authorityUtils;
    }

    @Bean
    public SecurityFilterChain filterChain(HttpSecurity http)throws Exception{
        http
                .headers().frameOptions().sameOrigin()
                .and()
                .csrf().disable() //배포할 때만 변경하면 됨.
                .cors(withDefaults())
                .sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS)
                .and()
                .formLogin().disable() //폼로그인 사용하지 않겟다.
                .httpBasic().disable()
                .apply(new CustomFilterConfigurer())
                .and()
              //  .authorizeHttpRequests(authorize -> authorize.anyRequest().permitAll())
                //  인증인가 구현 후 추가
                .authorizeHttpRequests(authorize -> authorize
                        .antMatchers(HttpMethod.POST, "/*/members").permitAll() //post에 해당한다면 접근 허용
                        .antMatchers(HttpMethod.PATCH, "/*/members/**").hasRole("USER")
                        .antMatchers(HttpMethod.GET, "/*/members").hasRole("ADMIN")
                        .antMatchers(HttpMethod.GET, "/*/members/**").hasAnyRole("USER", "ADMIN")
                        .antMatchers(HttpMethod.DELETE, "/*/members/**").hasRole("USER")
                        .anyRequest().permitAll()
                );
        return http.build();

    }

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

    //Cors설정 추가, corsConfigurationSource를 빈으로 동록
    @Bean
    CorsConfigurationSource corsConfigurationSource(){
        CorsConfiguration configuration = new CorsConfiguration();
        configuration.setAllowedOrigins(Arrays.asList("*"));
        configuration.setAllowedMethods(Arrays.asList("GET","POST","PATCH","DELETE"));
        UrlBasedCorsConfigurationSource source  = new UrlBasedCorsConfigurationSource();
        source.registerCorsConfiguration("/**",configuration);
       return source;
    }

    public class CustomFilterConfigurer extends AbstractHttpConfigurer<CustomFilterConfigurer,HttpSecurity>{
        @Override
        public void configure(HttpSecurity builder){
            AuthenticationManager authenticationManager = builder.getSharedObject(AuthenticationManager.class);

            JwtAuthenticationFilter jwtAuthenticationFilter = new JwtAuthenticationFilter(authenticationManager, jwtTokenizer);
            jwtAuthenticationFilter.setFilterProcessesUrl("/v11/auth/login"); //없을때는 기본적으로 로그인이 적용됨 ("/login)
            jwtAuthenticationFilter.setAuthenticationSuccessHandler(new MemberAuthenticationSuccessHandler());
            jwtAuthenticationFilter.setAuthenticationFailureHandler(new MemberAuthenticationFailureHandler());

            JwtVerifiedFilter jwtVerifiedFilter = new JwtVerifiedFilter(jwtTokenizer,authorityUtils);

            builder.addFilter(jwtAuthenticationFilter)
                    .addFilterAfter(jwtVerifiedFilter,JwtAuthenticationFilter.class);
        }
    }
}

• .authorizeHttpRequests(authorize -> authorize ~ : 접근 권한 부여 설정
  
  • .antMatchers(HttpMethod.POST, “/*/members”).permitAll() : HttpMethod가 POST에 해당하고 URL이 */members로 해당된다면 누구나 접근 허용
  • .antMatchers(HttpMethod.PATCH, “/*/members/**”).hasRole(“USER”) : PATCH 요청 시 members의 하위 URL이 어떤 URL이 오더라도 USER 권한 가졌으면 접근 허용
  • get 요청은 일반 사용자(USER)와 관리자(ADMIN) 권한을 가진 사용자 모두 접근이 가능
    
  • delete 요청은 해당 사용자가 탈퇴 같은 처리를 할 수 있어야 하므로 일반 사용자(USER) 권한만 가진 사용자만 접근이 가능하도록 허용

Spring 카테고리 내 다른 글 보러가기