스프링부트 게시판 API 만들기 (5) - JWT를 이용한 인증 (1) -JWT 관련 서비스 생성

 

 

 

 

 

이제 로그인까지 구현이 끝났으니 로그인이 성공하면 JWT를 발급하여서 AccessToken과 RefreshToken을 가지고 로그인 없이 인증을 처리하는 코드를 작성하겠습니다.

 

 

 

 

 

• 시큐리티를 이용한 JSON 데이터로 로그인 (완료)
• JWT를 이용한 인증 (진행 중)
• 도메인, 테이블 설계, 엔티티 생성
• 댓글 삭제 로직 구현
• 회원가입 + 정보수정 등 회원 서비스 구현
• 게시판 서비스 구현
• 댓글 서비스 구현 (1댓글 -> *(무한) 대댓글 구조)
• 예외 처리
• 예외 메세지 국제화
• 카테고리별 게시판 분류
• 게시글 페이징
• 동적인 검색 조건을 사용한 검색
• 사용자 간 쪽지 기능
• 무한 쪽지 스크롤
• 게시물 & 댓글에 대한 알람
• 쪽지에 대한 알람
• 접속한 사용자 간 실시간 채팅
• 회원가입 시 검증(예: XX대학교 XX과가 아니면 가입할 수 없게)
• Swagger를 사용한 API 문서 만들기
• 신고 & 블랙리스트 기능
• AOP를 통한 로그
• 어드민 페이지
• 캐시
• 배포 (+ 무중단 배포)
• 배포 자동화
• 포트와 어댑터 설계를 따르는 패키지 구조 설계하기
• ...

 

 

 

 

 

 

 

 

 

 

 

 

 

JWT에 대해서

우선 JWT에 대해서 공부하기 전에, JWT를 왜 쓰는지에 대해서 궁금하시다면 아래 사이트를 참고하시면 좋을 거 같습니다.

[무료] 스프링부트 시큐리티 & JWT 강의 - 인프런 | 강의

(웹 보안 이해 부분을 들으시면 좋을 거 같아요!)

 

 

 

 

JWT.IO

JWT(JSON Web Token)는 당사자 간에 정보를 JSON 개체로 안전하게 전송하기 위한 간결하고 자체 포함된 방법을 정의 하는 개방형 표준( RFC 7519 )입니다. 이 정보는 디지털 서명되어 있으므로 확인하고 신뢰할 수 있습니다. JWT는 비밀( HMAC 알고리즘 사용)을 사용 하거나 RSA 또는 ECDSA를 사용하는 공개/개인 키 쌍을 사용하여 서명할 수 있습니다 .
JWT를 암호화하여 당사자 간의 비밀도 제공할 수 있지만 서명된 토큰에 중점을 둘 것 입니다. 서명된 토큰은 그 안에 포함된 클레임 의 무결성 을 확인할 수 있는 반면 암호화된 토큰은 이러한 클레임을 다른 당사자로부터 숨길 수 있습니다. 공개/개인 키 쌍을 사용하여 토큰에 서명할 때 서명은 개인 키를 보유하고 있는 당사자만 서명했음을 증명합니다.

 

 

HMAC 알고리즘이나 RSA등의 알고리즘을 사용할 수 있는데 방식이 각각 다르며

공개/개인 키 쌍을 이용하여 서명을 할 수 있습니다. 

 

(서명은 쉽게 말하면, 이 토큰을 작성한 사람이 누구인지를 밝히는 것입니다.)

 

 

 

 

 

 

 

JWT는 대표적으로 다음 두 가지 경우에 사용하면 유용합니다.

 

• 권한 부여 : JWT를 사용하는 가장 일반적인 방식입니다. 사용자가 로그인하면 각 후속 요청에 JWT가 포함되어 사용자가 해당 토큰으로 서비스 및 리소스에 접근할 수 있습니다
• 정보 교환 : JWT는 정보를 안전하게 전송하는 좋은 방법입니다. 예를 들어 공개/개인 키 쌍을 사용하여 JWT에 서명할 수 있기 때문에 발신자가 누구인지 확인할 수 있습니다. 또한 헤더와 페이로드를 사용하여 서명을 계산하므로 콘텐츠가 변조되지 않았는지 확인할 수도 있습니다.

 

 

 

 

 

 

 

 

JWT의 구조

JWT의 구조는 다음과 같습니다

header.payload.signature   . 으로 구분합니다.

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

HEADER

토큰의 타입(type)과 해싱 알고리즘(alg)을 지정합니다.

 

알고리즘은 무엇을 사용했고, 타입은 무슨 타입이다를 나타냅니다.

 

보통 HMAC SHA256 혹은 RSA가 사용되며 토큰을 검증할 때 사용합니다.

 

 

저희는 HMAC512를 사용하여 암호화 및 복호화 하겠습니다. 

위의 사진처럼, JWT에 HS512 알고리즘을 적용하므로, 위와 같이 설정이 될 것입니다.

 

 

(참고로 암호화 방식에서 SHA는 해쉬를 사용한 암호화 방식으로, 복호화가 불가능합니다. 그러나 HMAC은 시크릿 키를 포함하여 암호화하는 방식입니다. 그리고 HS는, HMAC + SHA로 시크릿 키를 가지고 )

 

 

쉽게 말해 Header에는 토큰의 종류와 이 토큰의 암호화 방식이 적혀있습니다.

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

PAYLOAD

토큰에 담을 정보입니다.

 

토큰에 담을 하나의 정보, 한 조각의 정보를 클레임이라고 합니다

 

클레임은 name/value의 한 쌍으로 이루어져 있습니다.

 

클레임의 종류는 다음과 같이 3가지의 종류가 있습니다.

 

 

 

 

 

등록된 클레임 (registered claim) 

• 서비스에 필요한 정보가 아니라 토큰에 대한 정보들을 담기위해 이름이 이미 정해진 클레임입니다
• 필수는 아니지만 권장되는 클레임입니다.
• iss(발급자), sub(제목), aud(대상자), exp(만료시간), nbf(토큰의 활성날짜), iat(발급된시간), jti(JWT 고유식별자, 일회용 토큰에 사용)

 

 

 

 

공개 클레임 (public claim)

• 공개 클레임은 사용자 정의 클레임으로. 공개용 정보 전달을 위해 사용됩니다. 충돌 방지를 위해 URI 포맷을 이용해야 한다는데 언제 사용하는지는 잘 모르겠습니다.
  
  

 

 

 

 

비공개 클레임 (private claim)

• 비공개 클레임은 등록된 클레임도 아니고, 공개 클레임도 아닌 당사자간에 정보를 공유하기 위해 만들어진 사용자지정 클레임이다. 즉 이곳에 인증 정보 등의 서버와 클라이언트간 필요한 정보를 넣어두는 형식이겠죠?

 

 

Payload에는 정보가 들어 있습니다.

개발자가 정보를 더 추가할 수도 있습니다.

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

SIGNATURE

토큰을 인코딩하거나 유효성 검증을 할 때 사용하는 고유한 암호화 코드입니다

 

서명은 위에서 만든 헤더와 페이로드의 값을 각각 BASE64로 인코딩하고,

인코딩 한 값을 비밀 키를 이용하여 헤더에서 정한 알고리즘으로 해싱을 한 후 다시 BASE64로 인코딩하여 생성합니다.

HMACSHA256(
  base64UrlEncode(header) + "." +base64UrlEncode(payload),
  secret)

 

 

 

 

서명은 HS256 방식의 경우 우리가 만들었던 header와 payload, 그리고 나만 알고있는 개인 키를 넣어서 HS256 암호화 알고리즘을 사용하여 암호화를 하여서 사용합니다. 

 

이는 서버에서 클라이언트로부터 JWT를 받았을 때, JWT의 header와 payload를 서버에서 똑같이 HS256으로 암호화하여, 클라이언트가 보낸 JWT의 Signature와 같다면 요청된 것으로 알고 검증합니다.

 

만악 RSA라면,  시크릿 키를 넣지 않고, 서버의 개인 키로 잠군 후, 토큰을 전송합니다.

클라이언트는 해당 토큰을 받아서, 다시 서버에 전송할 때, 그냥 서버의 공개 키로 열어보기만 하면 됩니다.

 

 

 

 

 

 

 

 

 

 

 

 

JWT의 주의점

인증에서 사용자가 자격 증명을 사용하여 성공적으로 로그인하면 JSON 웹 토큰이 반환됩니다. 

 

토큰은 자격 증명을 주 목적으로 사용하므로 보안 문제를 방지하기 위해 세심한 주의를 기울여야 합니다. 

일반적으로 토큰을 필요 이상으로 오래 보관해서는 안 됩니다.

 

 

또한 보안이 취약하기 때문에 민감한 세션 데이터를 브라우저 저장소에 저장해서는 안됩니다.

 

클라이언트가 보호된 경로 또는 리소스에 접근하려고 할 때마다, 클라이언트는 일반적으로 Bearer 스키마를 사용하여 Authorization 헤더 에서 JWT를 보내야 합니다 .

 

 헤더의 내용은 다음과 같아야 합니다.

Authorization: Bearer <token>

이는 특정 경우에 상태 비저장 권한 부여 메커니즘이 될 수 있습니다. 

 

서버의 보호된 경로는 Authorization헤더에 유효한 JWT가 있는지 확인하고 JWT가 있는 경우 사용자는 보호된 리소스에 액세스할 수 있습니다. 

 

JWT에 필요한 데이터가 포함되어 있으면 특정 작업에 대해 데이터베이스를 쿼리해야 할 필요성이 줄어들 수 있지만 항상 그런 것은 아닙니다.

 

토큰이 Authorization헤더 로 전송되면 CORS(Cross-Origin Resource Sharing)는 쿠키를 사용하지 않으므로 문제가 되지 않습니다.

 

(지금까지 영어를 그대로 번역한 것이 많아 부자연스러운 내용이 있을 수 있습니다. 제가 나름 고치긴 했는데, 아직 잘 몰라서 함부로 제 느낌대로 고치는건 아닌 것 같아서요..)

 

 

 

 

 

 

 

 

 

 

 

 

 

JWT를 왜 쓸까요?

JWT가 Session에 비해 가지는 장점이 뭘까요?

 

AccessToken만 가지는 경우 확실하게 Stateless하게 인증 등의 정보를 처리할 수 있습니다.

이것 확실히 세션에 비해 장점을 가진다고 생각합니다.

 

그런데 RefreshToken을 사용하는 순간 StateLess에 대해서는 의문이 듭니다.

 

또 결국 RefreshToken을 DB에 저장하게 될 텐데, 그럼 Session을 사용하는 것과 다를 바 없지 않나 하는 생각이 듭니다.

 

여러 글을 찾아보았지만 명확한 답은 없는 것 같았습니다.

 

그나마 가지는 장점이라면 'Session에 비해 RefreshToken이 만료된 경우에만 DB에 접근하므로 I/O가 줄어 성능 향상이 된다' 정도였습니다.

 

 

 

관련 참조글

JWT를 굳이 사용하는 이유가 뭘까요? - 인프런 | 질문 & 답변

 

 

 

 

 

 

 

 

 

 

 

 

 

 

JWT 사용

다음 오픈소스 라이브러리를 사용하겠습니다.

https://github.com/auth0/java-jwt

GitHub - auth0/java-jwt: Java implementation of JSON Web Token (JWT)

 

 

 

 

 

 

 

build.gradle에 다음과 같은 의존성을 추가해줍니다.

implementation 'com.auth0:java-jwt:3.18.2'

 

 

 

전체 gradle은 아래와 같습니다.

plugins {
   id 'org.springframework.boot' version '2.6.2'
   id 'io.spring.dependency-management' version '1.0.11.RELEASE'
   id 'java'
}

group = 'boardexample'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = '17'

configurations {
   compileOnly {
      extendsFrom annotationProcessor
   }
}

repositories {
   mavenCentral()
}

dependencies {
   implementation 'org.springframework.boot:spring-boot-starter-data-jpa'
   implementation 'org.springframework.boot:spring-boot-starter-security'
   implementation 'org.springframework.boot:spring-boot-starter-validation'
   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'

   implementation 'com.auth0:java-jwt:3.18.2'
}

test {
   useJUnitPlatform()
}

 

 

 

 

 

 

 

 

Member 엔티티에 RefreshToken을 추가해줍니다.

@Column(length = 1000)
private String refreshToken;//RefreshToken

public void updateRefreshToken(String refreshToken){
        this.refreshToken = refreshToken;
    }
 public void destroyRefreshToken(){
        this.refreshToken = null;
    }

 

아래는 전체 코드입니다.

 

package boardexample.myboard.domain.member;

import boardexample.myboard.domain.BaseTimeEntity;
import lombok.*;
import org.springframework.security.crypto.password.PasswordEncoder;

import javax.persistence.*;

@Table(name = "MEMBER")
@Getter
@NoArgsConstructor(access = AccessLevel.PROTECTED)
@Entity
@AllArgsConstructor
@Builder
public class Member extends BaseTimeEntity {

    @Id @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "member_id")
    private Long id; //primary Key

    @Column(nullable = false, length = 30, unique = true)
    private String username;//아이디

    private String password;//비밀번호

    @Column(nullable = false, length = 30)
    private String name;//이름(실명)

    @Column(nullable = false, length = 30)
    private String nickName;//별명

    @Column(nullable = false, length = 30)
    private Integer age;//나이

    @Enumerated(EnumType.STRING)
    private Role role;//권한 -> USER, ADMIN


    @Column(length = 1000)
    private String refreshToken;//RefreshToken





    //== 정보 수정 ==//
    public void updatePassword(PasswordEncoder passwordEncoder, String password){
        this.password = passwordEncoder.encode(password);
    }

    public void updateName(String name){
        this.name = name;
    }

    public void updateNickName(String nickName){
        this.nickName = nickName;
    }

    public void updateAge(int age){
        this.age = age;
    }
    
    public void updateRefreshToken(String refreshToken){
        this.refreshToken = refreshToken;
    }
    
    public void destroyRefreshToken(){
        this.refreshToken = null;
    }
    
    

    //== 패스워드 암호화 ==//
    public void encodePassword(PasswordEncoder passwordEncoder){
        this.password = passwordEncoder.encode(password);
    }

}

 

 

 

 

 

 

 

 

 

 

 

 

MemberRepository에 RefreshToken을 통해 회원 조회하는 메서드 추가

public interface MemberRepository extends JpaRepository<Member, Long> {

    Optional<Member> findByUsername(String username);

    boolean existsByUsername(String username);

    Optional<Member> findByRefreshToken(String refreshToken);
}

 

 

 

 

 

 

 

 

 

 

 

 

 

JwtService 작성

JWT관련된 서비스(AccessToken 생성, RefreshToken생성, RefreshToken 재발급, RefreshToken 삭제, AccessToken 삭제 등)를 제공하는 클래스를 만들겠습니다.

 

우선 application.yml에 다음을 추가해줍니다.

spring:
  profiles:
    include: jwt

다음처럼 설정하면 application-jwt 에 해당하는 properties 혹은 yml 파일을 읽어올 수 있습니다.

이렇게 해서 jwt 관련된 설정은 application-jwt에서 설정해주도록 하겠습니다.

 

 

 

 

 

전체 설정은 아래와 같습니다.

spring:
  datasource:
    driver-class-name: org.h2.Driver
    url: jdbc:h2:tcp://localhost/~/jpa
    username: sa
    password: 1


  jpa:
    properties:
      hibernate:
        format_sql: true
        user_sql_cooments: true

    hibernate:
      ddl-auto: create


  profiles:
    include: jwt



logging:
  level:
    org:
      apache:
        coyote:
          http11: debug

      hiberante:
        SQL: debug

    boardexample:
      myboard: info

 

 

그리고 새로운 yml 파일인 application-jwt.yml을 생성해줍니다

 

 

 

 

해당 파일에서는 JWT 관련 시크릿 키라던가, 토큰의 만료 시간등을 설정해 주도록 하겠습니다.

jwt:
  secret: base64로 인코딩된 암호 키, HS512를 사용할 것이기 때문에, 512비트(64바이트) 이상이 되어야 합니다. 길게 써주세요

  access:
    expiration: 80
    header: Authorization

  refresh:
    expiration: 90
    header: Authorization-refresh

저는 accessToken은 80초, refreshToken은 90초로 설정을 해주었는데 나중에 바꿔줄 것입니다.

(리프레시토큰을 일부러 짧게 주었습니다.)

 

 

 

 

 

 

인터페이스부터 작성하도록 하겠습니다.

 

 

public interface JwtService {


    String createAccessToken(String username);
    String createRefreshToken();

    void updateRefreshToken(String username, String refreshToken);

    void destroyRefreshToken(String username);

    void sendToken(HttpServletResponse response, String accessToken, String refreshToken) throws IOException;

    String extractAccessToken(HttpServletRequest request) throws IOException, ServletException;

    String extractRefreshToken(HttpServletRequest request) throws IOException, ServletException;

    String extractUsername(String accessToken);

    void setAccessTokenHeader(HttpServletResponse response, String accessToken);
    void setRefreshTokenHeader(HttpServletResponse response, String refreshToken);
}

 

 

 

 

 

같은 패키지에 구현체도 생성하도록 하겠습니다.

package boardexample.myboard.global.jwt.service;

import boardexample.myboard.domain.member.repository.MemberRepository;
import com.auth0.jwt.JWT;
import com.auth0.jwt.algorithms.Algorithm;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import lombok.AccessLevel;
import lombok.Getter;
import lombok.RequiredArgsConstructor;
import lombok.Setter;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;
import java.util.Optional;

@Transactional
@Service
@RequiredArgsConstructor
@Setter(value = AccessLevel.PRIVATE)
public class JwtServiceImpl implements JwtService{

	//== 1 ==//
    @Value("${jwt.secret}")
    private String secret;
    @Value("${jwt.access.expiration}")
    private long accessTokenValidityInSeconds;
    @Value("${jwt.refresh.expiration}")
    private long refreshTokenValidityInSeconds;
    @Value("${jwt.access.header}")
    private String accessHeader;
    @Value("${jwt.refresh.header}")
    private String refreshHeader;



	//== 2 ==//
    private static final String ACCESS_TOKEN_SUBJECT = "AccessToken";
    private static final String REFRESH_TOKEN_SUBJECT = "RefreshToken";
    private static final String USERNAME_CLAIM = "username";
    private static final String BEARER = "Bearer ";


    private final MemberRepository memberRepository;
    private final ObjectMapper objectMapper;




    //== 3 ==//
    @Override
    public String createAccessToken(String username) {
        return JWT.create()
                .withSubject(ACCESS_TOKEN_SUBJECT)
                .withExpiresAt(new Date(System.currentTimeMillis() + accessTokenValidityInSeconds * 1000))
                .withClaim(USERNAME_CLAIM, username)
                .sign(Algorithm.HMAC512(secret));
    }

    @Override
    public String createRefreshToken() {
        return JWT.create()
                .withSubject(REFRESH_TOKEN_SUBJECT)
                .withExpiresAt(new Date(System.currentTimeMillis() + refreshTokenValidityInSeconds * 1000))
                .sign(Algorithm.HMAC512(secret));
    }

    @Override
    public void updateRefreshToken(String username, String refreshToken) {
        memberRepository.findByUsername(username)
                .ifPresentOrElse(
                        member -> member.updateRefreshToken(refreshToken),
                        () -> new Exception("회원이 없습니다")
                        );
    }



    @Override
    public void destroyRefreshToken(String username) {
        memberRepository.findByUsername(username)
                .ifPresentOrElse(
                        member -> member.destroyRefreshToken(),
                        () -> new Exception("회원이 없습니다")
                );
    }

    //== 5 ==//
    @Override
    public void sendToken(HttpServletResponse response, String accessToken, String refreshToken) throws IOException {
        response.setContentType("application/json;charset=UTF-8");
        response.setStatus(HttpServletResponse.SC_OK);

        setAccessTokenHeader(response, accessToken);
        setRefreshTokenHeader(response, refreshToken);
       

        Map<String, String> tokenMap = new HashMap<>();
        tokenMap.put(ACCESS_TOKEN_SUBJECT, accessToken);
        tokenMap.put(REFRESH_TOKEN_SUBJECT, refreshToken);

        String token = objectMapper.writeValueAsString(tokenMap);

        response.getWriter().write(token);
    }
    

    @Override
    public String extractAccessToken(HttpServletRequest request) throws IOException, ServletException {
        return Optional.ofNullable(request.getHeader(accessHeader)).map(accessToken -> accessToken.replace(BEARER, "")).orElse(null);
    }

    @Override
    public String extractRefreshToken(HttpServletRequest request) throws IOException, ServletException {
        return Optional.ofNullable(request.getHeader(refreshHeader)).map(refreshToken -> refreshToken.replace(BEARER, "")).orElse(null);
    }

	//== 4 ==//
    @Override
    public String extractUsername(String accessToken) {
        return JWT.require(Algorithm.HMAC512(secret)).build().verify(accessToken).getClaim(USERNAME_CLAIM).asString();

    }

    @Override
    public void setAccessTokenHeader(HttpServletResponse response, String accessToken) {
        response.setHeader(accessHeader, accessToken);
    }

    @Override
    public void setRefreshTokenHeader(HttpServletResponse response, String refreshToken) {
        response.setHeader(refreshHeader, refreshToken);
    }
}

 

1. @Vaule를 사용하여 yml 파일에 작성해둔 설정 값들을 가져와서 사용했습니다.

저희는 jwt.secret, jwt.access.expiration, 등 값들을 바로 위에서 세팅해 주었기 때문에, @Value를 통해 사용할 수 있으며, 필드를 static으로 선언 시 값이 들어오지 않으니 주의하세요.

 

 

 

2. JWT에 넣어줄 Subject와, Claim으로 username을 사용할 것이기에 클레임의 name을 "username"으로 지정해 주었습니다. 그리고 항상 JWT의 헤더에 들어오는 값으로는 'Authorization = Bearer [토큰]' 의 형식을 취하게 할 것이기에 BEARER을 미리 지정해 주었습니다.

 

 

 

3. 다른 코드들도 이거 하나만 보면, 이름과 코드를 통해 충분히 무얼 하는 코드인지 아실거라 예상하고 넘어가겠습니다.

 

 

 

 

AccessToken을 만드는 코드를 보겠습니다.

JWT.create() //JWT 토큰을 생성하는 빌더를 반환합니다.

	.withSubject(ACCESS_TOKEN_SUBJECT) 
    //빌더를 통해 JWT의 Subject를 정합니다. AccessToken이므로 저는 위에서 설정했던 
    //AccessToken의 subject를 가져와 사용하겠습니다
    
	.withExpiresAt(new Date(System.currentTimeMillis() + accessTokenValidityInSeconds * 1000))
    //만료시간을 설정하는 것입니다. 현재 시간 + 저희가 설정한 시간(밀리초) * 1000을 하면
    //예를 들어 저의 경우는 accessTokenValidityInSeconds이 80이기 때문에
    //현재시간에 80 * 1000 밀리초를 더한 '현재시간 + 80초'가 설정이 되고
    //따라서 80초 이후에 이 토큰은 만료됩니다.
    
	.withClaim(USERNAME_CLAIM, username)
    //클레임으로는 저희는 username 하나만 사용합니다.
    //추가적으로 식별자나, 이름 등의 정보를 더 추가하셔도 됩니다.
    //추가하실 경우 .withClaim(클래임 이름, 클래임 값) 으로 설정해주시면 됩니다
    
	.sign(Algorithm.HMAC512(secret));
    //저희는 HMAC512 알고리즘을 사용하여, 저희가 지정한 secret 키로 암호화 할 것입니다.

추가로 refreshToken에는 username을 넣지 않습니다. 이는 AccessToken을 제발급 할 용도로 사용하기에, 가급적 정도는 넣지 않고, DB에 저장하여 관리하겠습니다.

 

 

 

 

 

4. Token에서 username을 추출하는 코드입니다.

JWT.require(Algorithm.HMAC512(secret))
//토큰의 서명의 유효성을 검사하는데 사용할 알고리즘이 있는
//JWT verifier builder를 반환합니다

    .build()//반환된 빌더로 JWT verifier를 생성합니다
    
    .verify(accessToken)//accessToken을 검증하고 유효하지 않다면 예외를 발생시킵니다.
    .getClaim(USERNAME_CLAIM)//claim을 가져옵니다
    .asString();

 

5. accessToken과 refreshToken을 헤더와 바디에 둘 다 세팅해 주었는데, 이는 알아서 구현하시면 됩니다.

헤더에만 하실거면 바디에 세팅해주는 부분을 빼셔도 상관없습니다.

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

테스트코드 작성

이제 해당 서비스가 잘 작동하는지 테스트코드를 작성하도록 하겠습니다. 이후 Filter에 적용하여 인증을 진행하도록 하겠습니다.

 

 

 

 

기본 구성

@SpringBootTest
@Transactional
class JwtServiceTest {



    @Autowired JwtService jwtService;
    @Autowired MemberRepository memberRepository;
    @Autowired EntityManager em;

    @Value("${jwt.secret}")
    private String secret;
    @Value("${jwt.access.header}")
    private String accessHeader;
    @Value("${jwt.refresh.header}")
    private String refreshHeader;

    private static final String ACCESS_TOKEN_SUBJECT = "AccessToken";
    private static final String REFRESH_TOKEN_SUBJECT = "RefreshToken";
    private static final String USERNAME_CLAIM = "username";
    private static final String BEARER = "Bearer ";


    private String username = "username";

    @BeforeEach
    public void init(){
        Member member = Member.builder().username(username).password("1234567890").name("Member1").nickName("NickName1").role(Role.USER).age(22).build();
        memberRepository.save(member);
        clear();
    }

    private void clear(){
        em.flush();
        em.clear();
    }

    private DecodedJWT getVerify(String token) {
        return JWT.require(HMAC512(secret)).build().verify(token);
    }

 

 

 

 

 

 

 

 

 

AccessToken 발급 테스트

    @Test
    public void createAccessToken_AccessToken_발급() throws Exception {
        //given, when
        String accessToken = jwtService.createAccessToken(username);

        DecodedJWT verify = getVerify(accessToken);

        String subject = verify.getSubject();
        String findUsername = verify.getClaim(USERNAME_CLAIM).asString();

        //then
        assertThat(findUsername).isEqualTo(username);
        assertThat(subject).isEqualTo(ACCESS_TOKEN_SUBJECT);
    }

 

 

 

 

 

 

 

 

 

RefreshToken 발급 테스트

    @Test
    public void createRefreshToken_RefreshToken_발급() throws Exception {
        //given, when
        String refreshToken = jwtService.createRefreshToken();
        DecodedJWT verify = getVerify(refreshToken);
        String subject = verify.getSubject();
        String username = verify.getClaim(USERNAME_CLAIM).asString();

        //then
        assertThat(subject).isEqualTo(REFRESH_TOKEN_SUBJECT);
        assertThat(username).isNull();
    }

refreshToken은 username이 없어야 합니다.

 

 

 

 

 

 

 

 

 

 

 

RefreshToken 업데이트

    @Test
    public void updateRefreshToken_refreshToken_업데이트() throws Exception {
        //given
        String refreshToken = jwtService.createRefreshToken();
        jwtService.updateRefreshToken(username, refreshToken);
        clear();
        Thread.sleep(3000);

        //when
        String reIssuedRefreshToken = jwtService.createRefreshToken();
        jwtService.updateRefreshToken(username, reIssuedRefreshToken);
        clear();

        //then
        assertThrows(Exception.class, () -> memberRepository.findByRefreshToken(refreshToken).get());//
        assertThat(memberRepository.findByRefreshToken(reIssuedRefreshToken).get().getUsername()).isEqualTo(username);
    }

3초를 sleep 한 이유는, 이를 해주지 않으면 refreshToken이 똑같이 발급될수가 있습니다.

 

 

 

 

 

 

 

 

 

RefreshToken 제거

    @Test
    public void destroyRefreshToken_refreshToken_제거() throws Exception {
        //given
        String refreshToken = jwtService.createRefreshToken();
        jwtService.updateRefreshToken(username, refreshToken);
        clear();

        //when
        jwtService.destroyRefreshToken(username);
        clear();

        //then
        assertThrows(Exception.class, () -> memberRepository.findByRefreshToken(refreshToken).get());

        Member member = memberRepository.findByUsername(username).get();
        assertThat(member.getRefreshToken()).isNull();
    }

 

 

 

 

 

 

 

 

 

AccessToken, RefreshToken 헤더 설정 테스트

    @Test
    public void setAccessTokenHeader_AccessToken_헤더_설정() throws Exception {
        MockHttpServletResponse mockHttpServletResponse = new MockHttpServletResponse();

        String accessToken = jwtService.createAccessToken(username);
        String refreshToken = jwtService.createRefreshToken();

        jwtService.setAccessTokenHeader(mockHttpServletResponse, accessToken);


        //when
        jwtService.sendToken(mockHttpServletResponse,accessToken,refreshToken);

        //then
        String headerAccessToken = mockHttpServletResponse.getHeader(accessHeader);

        assertThat(headerAccessToken).isEqualTo(accessToken);
    }



    @Test
    public void setRefreshTokenHeader_RefreshToken_헤더_설정() throws Exception {
        MockHttpServletResponse mockHttpServletResponse = new MockHttpServletResponse();

        String accessToken = jwtService.createAccessToken(username);
        String refreshToken = jwtService.createRefreshToken();

        jwtService.setRefreshTokenHeader(mockHttpServletResponse, refreshToken);


        //when
        jwtService.sendAccessAndRefreshToken(mockHttpServletResponse,accessToken,refreshToken);

        //then
        String headerRefreshToken = mockHttpServletResponse.getHeader(refreshHeader);

        assertThat(headerRefreshToken).isEqualTo(refreshToken);
    }

 

 

 

 

 

 

 

 

 

토큰 전송 테스트

	@Test
	public void sendToken_토큰_전송() throws Exception {
		//given
		MockHttpServletResponse mockHttpServletResponse = new MockHttpServletResponse();

		String accessToken = jwtService.createAccessToken(username);
		String refreshToken = jwtService.createRefreshToken();


		//when
		jwtService.sendToken(mockHttpServletResponse,accessToken,refreshToken);


		//then
		String headerAccessToken = mockHttpServletResponse.getHeader(accessHeader);
		String headerRefreshToken = mockHttpServletResponse.getHeader(refreshHeader);



		assertThat(headerAccessToken).isEqualTo(accessToken);
		assertThat(headerRefreshToken).isEqualTo(refreshToken);

	}

 

 

 

 

 

 

 

 

 

 

 

 

 

 

AccessToken 추출 테스트

토큰 전송 테스트를 마쳤으니, 반복되는 토큰 전송 코드를 줄이기 위해 메서드를 하나 작성하겠습니다.

private HttpServletRequest setRequest(String accessToken, String refreshToken) throws IOException {

    MockHttpServletResponse mockHttpServletResponse = new MockHttpServletResponse();
    jwtService.sendToken(mockHttpServletResponse,accessToken,refreshToken);

    String headerAccessToken = mockHttpServletResponse.getHeader(accessHeader);
    String headerRefreshToken = mockHttpServletResponse.getHeader(refreshHeader);

    MockHttpServletRequest httpServletRequest = new MockHttpServletRequest();

    httpServletRequest.addHeader(accessHeader, BEARER+headerAccessToken);
    httpServletRequest.addHeader(refreshHeader, BEARER+headerRefreshToken);

    return httpServletRequest;
}

토큰을 header에 넣어서 전송해주는 메서드입니다.

 

 

 

 

 

 

 

이제 테스트코드를 작성하겠습니다.

    @Test
    public void extractAccessToken_AccessToken_추출() throws Exception {
        //given
        String accessToken = jwtService.createAccessToken(username);
        String refreshToken = jwtService.createRefreshToken();
        HttpServletRequest httpServletRequest = setRequest(accessToken, refreshToken);

        //when
        String extractAccessToken = jwtService.extractAccessToken(httpServletRequest);


        //then
        assertThat(extractAccessToken).isEqualTo(accessToken);
        assertThat(getVerify(extractAccessToken).getClaim(USERNAME_CLAIM).asString()).isEqualTo(username);
    }

 

 

 

 

 

 

 

 

 

 

RefreshToken 추출 테스트

    @Test
    public void extractRefreshToken_RefreshToken_추출() throws Exception {
        //given
        String accessToken = jwtService.createAccessToken(username);
        String refreshToken = jwtService.createRefreshToken();
        HttpServletRequest httpServletRequest = setRequest(accessToken, refreshToken);


        //when
        String extractRefreshToken = jwtService.extractRefreshToken(httpServletRequest);


        //then
        assertThat(extractRefreshToken).isEqualTo(refreshToken);
        assertThat(getVerify(extractRefreshToken).getSubject()).isEqualTo(REFRESH_TOKEN_SUBJECT);
    }

 

 

 

 

 

 

 

 

 

 

 

Username 추출 테스트

    @Test
    public void extractUsername_Username_추출() throws Exception {
        //given
        String accessToken = jwtService.createAccessToken(username);
        String refreshToken = jwtService.createRefreshToken();
        HttpServletRequest httpServletRequest = setRequest(accessToken, refreshToken);

        String requestAccessToken = jwtService.extractAccessToken(httpServletRequest);

        //when
        String extractUsername = jwtService.extractUsername(requestAccessToken);


        //then
        assertThat(extractUsername).isEqualTo(username);
    }

 

 

 

 

 

 

 

 

 

 

전체 테스트코드

@SpringBootTest
@Transactional
class JwtServiceImplTest {

	@Autowired
	JwtService jwtService;
	@Autowired
	MemberRepository memberRepository;
	@Autowired
	EntityManager em;

	@Value("${jwt.secret}")
	private String secret;
	@Value("${jwt.access.header}")
	private String accessHeader;
	@Value("${jwt.refresh.header}")
	private String refreshHeader;

	private static final String ACCESS_TOKEN_SUBJECT = "AccessToken";
	private static final String REFRESH_TOKEN_SUBJECT = "RefreshToken";
	private static final String USERNAME_CLAIM = "username";
	private static final String BEARER = "Bearer ";

	private String username = "username";

	@BeforeEach
	public void init() {
		Member member = Member.builder()
			.username(username)
			.password("1234567890")
			.name("Member1")
			.nickName("NickName1")
			.role(Role.USER)
			.age(22)
			.build();
		memberRepository.save(member);
		clear();
	}

	private void clear() {
		em.flush();
		em.clear();
	}

	private DecodedJWT getVerify(String token) {
		return JWT.require(HMAC512(secret)).build().verify(token);
	}

	@Test
	public void createAccessToken_AccessToken_발급() throws Exception {
		//given, when
		String accessToken = jwtService.createAccessToken(username);

		DecodedJWT verify = getVerify(accessToken);

		String subject = verify.getSubject();
		String findUsername = verify.getClaim(USERNAME_CLAIM).asString();

		//then
		assertThat(findUsername).isEqualTo(username);
		assertThat(subject).isEqualTo(ACCESS_TOKEN_SUBJECT);
	}

	@Test
	public void createRefreshToken_RefreshToken_발급() throws Exception {
		//given, when
		String refreshToken = jwtService.createRefreshToken();
		DecodedJWT verify = getVerify(refreshToken);
		String subject = verify.getSubject();
		String username = verify.getClaim(USERNAME_CLAIM).asString();

		//then
		assertThat(subject).isEqualTo(REFRESH_TOKEN_SUBJECT);
		assertThat(username).isNull();
	}


	@Test
	public void updateRefreshToken_refreshToken_업데이트() throws Exception {
		//given
		String refreshToken = jwtService.createRefreshToken();
		jwtService.updateRefreshToken(username, refreshToken);
		clear();
		Thread.sleep(3000);

		//when
		String reIssuedRefreshToken = jwtService.createRefreshToken();
		jwtService.updateRefreshToken(username, reIssuedRefreshToken);
		clear();

		//then
		assertThrows(Exception.class, () -> memberRepository.findByRefreshToken(refreshToken).get());//
		assertThat(memberRepository.findByRefreshToken(reIssuedRefreshToken).get().getUsername()).isEqualTo(username);
	}

	@Test
	public void destroyRefreshToken_refreshToken_제거() throws Exception {
		//given
		String refreshToken = jwtService.createRefreshToken();
		jwtService.updateRefreshToken(username, refreshToken);
		clear();

		//when
		jwtService.destroyRefreshToken(username);
		clear();

		//then
		assertThrows(Exception.class, () -> memberRepository.findByRefreshToken(refreshToken).get());

		Member member = memberRepository.findByUsername(username).get();
		assertThat(member.getRefreshToken()).isNull();
	}



	@Test
	public void setAccessTokenHeader_AccessToken_헤더_설정() throws Exception {
		MockHttpServletResponse mockHttpServletResponse = new MockHttpServletResponse();

		String accessToken = jwtService.createAccessToken(username);
		String refreshToken = jwtService.createRefreshToken();

		jwtService.setAccessTokenHeader(mockHttpServletResponse, accessToken);


		//when
		jwtService.sendToken(mockHttpServletResponse,accessToken,refreshToken);

		//then
		String headerAccessToken = mockHttpServletResponse.getHeader(accessHeader);

		assertThat(headerAccessToken).isEqualTo(accessToken);
	}



	@Test
	public void setRefreshTokenHeader_RefreshToken_헤더_설정() throws Exception {
		MockHttpServletResponse mockHttpServletResponse = new MockHttpServletResponse();

		String accessToken = jwtService.createAccessToken(username);
		String refreshToken = jwtService.createRefreshToken();

		jwtService.setRefreshTokenHeader(mockHttpServletResponse, refreshToken);


		//when
		jwtService.sendToken(mockHttpServletResponse,accessToken,refreshToken);

		//then
		String headerRefreshToken = mockHttpServletResponse.getHeader(refreshHeader);

		assertThat(headerRefreshToken).isEqualTo(refreshToken);
	}



	@Test
	public void sendToken_토큰_전송() throws Exception {
		//given
		MockHttpServletResponse mockHttpServletResponse = new MockHttpServletResponse();

		String accessToken = jwtService.createAccessToken(username);
		String refreshToken = jwtService.createRefreshToken();


		//when
		jwtService.sendToken(mockHttpServletResponse,accessToken,refreshToken);


		//then
		String headerAccessToken = mockHttpServletResponse.getHeader(accessHeader);
		String headerRefreshToken = mockHttpServletResponse.getHeader(refreshHeader);



		assertThat(headerAccessToken).isEqualTo(accessToken);
		assertThat(headerRefreshToken).isEqualTo(refreshToken);

	}



	private HttpServletRequest setRequest(String accessToken, String refreshToken) throws IOException {

		MockHttpServletResponse mockHttpServletResponse = new MockHttpServletResponse();
		jwtService.sendToken(mockHttpServletResponse,accessToken,refreshToken);

		String headerAccessToken = mockHttpServletResponse.getHeader(accessHeader);
		String headerRefreshToken = mockHttpServletResponse.getHeader(refreshHeader);

		MockHttpServletRequest httpServletRequest = new MockHttpServletRequest();

		httpServletRequest.addHeader(accessHeader, BEARER+headerAccessToken);
		httpServletRequest.addHeader(refreshHeader, BEARER+headerRefreshToken);

		return httpServletRequest;
	}

	@Test
	public void extractAccessToken_AccessToken_추출() throws Exception {
		//given
		String accessToken = jwtService.createAccessToken(username);
		String refreshToken = jwtService.createRefreshToken();
		HttpServletRequest httpServletRequest = setRequest(accessToken, refreshToken);

		//when
		String extractAccessToken = jwtService.extractAccessToken(httpServletRequest);


		//then
		assertThat(extractAccessToken).isEqualTo(accessToken);
		assertThat(getVerify(extractAccessToken).getClaim(USERNAME_CLAIM).asString()).isEqualTo(username);
	}


	@Test
	public void extractRefreshToken_RefreshToken_추출() throws Exception {
		//given
		String accessToken = jwtService.createAccessToken(username);
		String refreshToken = jwtService.createRefreshToken();
		HttpServletRequest httpServletRequest = setRequest(accessToken, refreshToken);


		//when
		String extractRefreshToken = jwtService.extractRefreshToken(httpServletRequest);


		//then
		assertThat(extractRefreshToken).isEqualTo(refreshToken);
		assertThat(getVerify(extractRefreshToken).getSubject()).isEqualTo(REFRESH_TOKEN_SUBJECT);
	}


	@Test
	public void extractUsername_Username_추출() throws Exception {
		//given
		String accessToken = jwtService.createAccessToken(username);
		String refreshToken = jwtService.createRefreshToken();
		HttpServletRequest httpServletRequest = setRequest(accessToken, refreshToken);

		String requestAccessToken = jwtService.extractAccessToken(httpServletRequest);

		//when
		String extractUsername = jwtService.extractUsername(requestAccessToken);


		//then
		assertThat(extractUsername).isEqualTo(username);
	}
}

 

 

다음번에는 해당 JwtService를 가지고, 시큐리티 필터에 추가하여 인증을 진행해보도록 하겠습니다.

 

 

감사합니다

 

 

 

 

 

 

전체 코드는 깃허브에서 확인하실 수 있습니다.

 

https://github.com/ShinDongHun1/SpringBoot-Board-API

GitHub - ShinDongHun1/SpringBoot-Board-API

 

 

 

 

 

 

 

 

 

📔 Reference

스프링에서 JWT 사용 참고

[무료] 스프링부트 시큐리티 & JWT 강의 - 인프런 | 강의

 

 

게시판 참고

스프링부트 게시판 API 서버 만들기 (1) - 프로젝트 생성

 

 

 

JWT 참고

JWT (토큰 기반 인증 방식) 의 이해

 

JWT란 무엇인가

 

JWT(JSON Web Token) 란 무엇인가?

 

JWT란?

 

JWT.IO