[내일배움캠프_Spring Boot 숙련주차] 인증과 인가(+쿠키-세션, JWT)

인증과 인가란 무엇일까?

인증과 인가

인증과 인가

인증(Authentication): 해당 유저가 실제 유저인지 인증하는 개념

인가(Authorization): 해당 유저가 특정 리소스에 접근이 가능한지 허가를 확인하는 개념으로, 관리자 페이지-관리자 권한 같은 것이 있음

 

쉽게 설명하면, 로그인은 인증을 할 때(비밀번호 입력하고 제출할 때)이고, 회원/비회원 여부에 따라 다른 권한을 받는 것은 인가임

웹 애플리케이션 인증의 특수성

웹 애플리케이션 인증

HTTP는 비연결성(Connectionless)와 무상태(Stateless)로 이루어져 있음 → 서버의 비용을 줄이기 위해

• 비연결성(Connectionless): 서버와 클라이언트가 연결이 되어 있지 않음을 의미
  즉, 서버는 하나의 요청에 대해서 응답을 내보내고 연결을 끊음
• 무상태(Stateless): 서버가 클라이언트의 상태를 저장하고 있지 않음을 의미
  즉, 서버는 클라이언트가 직전에 혹은 그 전에 어떠한 요청을 보냈는지 관심도 없고 전혀 알 수 없음

HTTP가 이러한 특징을 가지고 있지만, 우리가 인터넷을 사용할 때는 이전 정보들이 잘 있는 것처럼 뭔가 연속성 있게 사용해옴.

예를 들어, 유저 인증도 하나의 상태 값인데 그 정보를 어떻게 유지시키고 있는 것인가?

인증의 방식

웹 애플리케이션은 두 가지 방법을 통해 인증을 처리함

 

1. 쿠키-세션 방식의 인증

쿠키(Cookie): 토큰 저장소
세션: 인증 정보

• 쿠키-세션 방식은 서버가 '특정 유저가 로그인이 되었다'라는 상태를 저장하는 방식 중 하나
• 인증과 관련된 약간의 정보를 서버가 가지고 있음. 즉, 유저의 이전 상태 전부는 아니더라도 인증하고 관련된 최소한의 정보를 저장해서 로그인을 유지시킴

쿠키-세션 방식 인증

1) 사용자가 로그인을 진행

2) 서버에서 회원 데이터베이스를 대조해서 사용자 확인함

3) 실제 유저 테이블의 정보와 일치한다면 인증이 통과되었다고 보고, 세션 저장소에 해당 유저가 로그인이 되었다라는 정보를 저장함

4) 세션 저장소에서는 유저의 정보와는 관련없는 난수인 세션 ID를 발급

5) 서버는 발급받은 세션 ID를 응답에 담아서 사용자에게 보냄

6) 클라이언트(사용자)는 세션 ID를 브라우저 내의 쿠키(Cookie)라는 저장소에 보관하고 있다가, 요청을 할 때마다 해당 세션 ID를 같이 보냄 → 주로 HTTP Header에 담겨서 보내짐

7) 서버는 클라이언트 요청에서 쿠키 발견하면 서버의 세션 저장소에 저장되어 있던 정보랑 비교해서 검증함

8) 유저 정보를 제대로 받아왔다면 사용자는 로그인이 된 사용자라고 인증이 되어, 그 이후에는 로그인이 된 유저에 따른 응답을 보내줌

 

2. JWT 기반 인증

JWT(JSON Web Token)은 JSON 형식으로 생긴 웹에서 사용하는 토큰

• JWT는 인증에 필요한 정보들을 암호화시켜 놓음
• JWT 기반 인증은 쿠키-세션 방식과 유사하게 JWT를 HTTP Header에 실어서 서버가 클라이언트를 식별할 수 있음

1) 사용자가 로그인을 진행

2) 서버에서 회원 데이터베이스를 대조해서 사용자 확인함

3) 실제 유저 테이블의 정보와 일치한다면 인증이 통과되었다고 보고, 유저에 대한 정보를 JWT로 암호화함

4) 암호화된 토큰(Access Token)인 JWT를 응답에 실어서 내보냄(Body 혹은 Header)

5) 클라이언트(사용자)는 토큰을 쿠키 저장소 혹은 로컬 스토리지에 저장해 놓았다가, 요청을 할 때마다 해당하는 JWT 토큰을 같이 보냄

6) 서버는 작성해놓은 검증 로직을 통해 토큰을 검증 후, 유저에 따른 응답을 내보냄

 

﹡쿠키-세션 방식에서는 발급한 세션을 저장할 공간이 필요하지만, JWT는 따로 토큰을 저장할 필요가 없음

따라서 JWT가 훨씬 쿠키-세션 방식보다 서버에 부담이 덜하기 때문에 훨씬 효율적임

---

쿠키와 세션이란 무엇일까?

쿠키와 세션

쿠키와 세션 모두 HTTP에 상태 정보를 유지(Stateful)하기 위해 사용되는 것으로, 쿠키와 세션을 통해 서버에서는 클라이언트 별로 인증 및 인가를 할 수 있음

 

쿠키(Cookie)

클라이언트에 저장될 목적으로 생성한 작은 정보를 담은 파일

• 크롬 브라우저 기준 > 개발자 도구 > Application > Storage > Cookies에 도메인 별로 저장되어 있음

크롬 브라우저 내 쿠키 저장소

[구성 요소]

• 이름(Name): 쿠키를 구별하는데 사용되는 Key
• 값(Value): 쿠키의 값
• 도메인(Domain): 쿠키가 저장된 도메인으로, 여러 경로에 나눠서 쿠키가 저장될 수도 있음
• 경로(Path): 'Domain Local/API' 이런식으로 구분 가능
• Expires/Max-Age: 만료 기한으로, 쿠키를 만들 때 만료 기한을 줄 수 있음. 만료 기한이 지나면 삭제됨
• 크기(Size)
• HttpOnly
• Secure
• 등등

세션(Session)

서버에서 일정시간 동안 클라이언트 상태를 유지하기 위해 사용되는 것

• 서버에서 클라이언트 별로 유일무이한 '세션 ID'를 부여한 후 클라이언트 별 필요한 정보를 서버에 저장함
• 서버에서 생성한 '세션 ID'는 클라이언트의 쿠키값('세션 쿠키'라고 부름)으로 저장되어 클라이언트 식별에 사용됨

[세션 동작 방식]

세션 동작

1) 클라이언트가 첫 번째 요청을 하면, 서버에서 세션 ID를 생성해서 쿠키에 담아서 응답 Header에 전달함

2) 세션 ID가 클라이언트의 쿠키 저장소에 저장됨(Set-Cookie: 세션 ID)

3) 이어서 클라이언트가 두 번째 요청을 보낼 때, 해당하는 세션 ID 값을 같이 포함해서 보냄

4) 서버는 해당하는 세션 ID를 확인하고, 같은 브라우저에서 요청한 HTTP 요청(=같은 클라이언트의 요청)임을 확인함

 

쿠키와 세션 비교

	쿠키(Cookie)	세션(Session)
설명	클라이언트에 저장될 목적으로 생성한 작은 정보를 담은 파일	서버에서 일정시간 동안 클라이언트 상태를 유지하기 위해 사용
저장 위치	클라이언트 (웹 브라우저)	웹 서버
사용 예	사이트 팝업의 "오늘 다시보지 않기" 정보 저장	로그인 정보 저장
만료 시점	쿠키 저장 시 만료일시 설정 가능 (브라우저 종료시도 유지 가능)	다음 조건 중 하나가 만족될 경우 만료됨 - 브라우저 종료 시까지 - 클라이언트 로그아웃 시까지 - 서버에 설정한 유지기간까지 해당 클라이언트의 재요청이 없는 경우
용량 제한	브라우저 별로 다름(크롬 기준) - 하나의 도메인 당 180개 - 하나의 쿠키 당 4KB(=4096byte)	개수 제한 없음 (단, 세션 저장소 크기 이상 저장 불가능)
보안	취약 (클라이언트에서 쿠키 정보를 쉽게 변경, 삭제 및 가로채기 당할 수 있음)	비교적 안전 (서버에 저장되기 때문에 상대적으로 안전)

 

Spring에서 쿠키-세션 다뤄보기

쿠키 생성하고 가져오기

package com.sparta.springauth.auth;

import jakarta.servlet.http.Cookie;
import jakarta.servlet.http.HttpServletResponse;
import org.springframework.web.bind.annotation.CookieValue;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.io.UnsupportedEncodingException;
import java.net.URLEncoder;

@RestController
@RequestMapping("/api")
public class AuthController {

    public static final String AUTHORIZATION_HEADER = "Authorization";

    // 쿠키 생성하는 메서드
    @GetMapping("/create-cookie")
    public String createCookie(HttpServletResponse res) {
        addCookie("Robbie Auth", res);

        return "createCookie";
    }

    // 쿠키 가져오는 메서드
    @GetMapping("/get-cookie")
    public String getCookie(@CookieValue(AUTHORIZATION_HEADER) String value) {
        System.out.println("value = " + value);

        return "getCookie : " + value;
    }

    public static void addCookie(String cookieValue, HttpServletResponse res) {
        try {
            cookieValue = URLEncoder.encode(cookieValue, "utf-8").replaceAll("\\+", "%20"); // Cookie Value 에는 공백이 불가능해서 encoding 진행

            // Spring에서 쿠키 클래스 제공함
            Cookie cookie = new Cookie(AUTHORIZATION_HEADER, cookieValue); // Name-Value
            cookie.setPath("/");
            cookie.setMaxAge(30 * 60);

            // Response 객체에 Cookie 추가
            res.addCookie(cookie);
        } catch (UnsupportedEncodingException e) {
            throw new RuntimeException(e.getMessage());
        }
    }
}

쿠키 저장하는 코드 실행 화면

쿠키 가져오는 코드 실행

 

세션 생성하고 가져오기

Servlet에서 유일무이한 세션 ID를 간편하게 만들어주는 HttpSession 제공해줌

@GetMapping("/create-session")
public String createSession(HttpServletRequest req) {
    // 세션이 존재할 경우 세션 반환, 없을 경우 새로운 세션을 생성한 후 반환
    HttpSession session = req.getSession(true);

    // 세션에 저장될 정보 Name - Value 를 추가합니다.
    session.setAttribute(AUTHORIZATION_HEADER, "Robbie Auth");

    return "createSession";
}

@GetMapping("/get-session")
public String getSession(HttpServletRequest req) {
    // 세션이 존재할 경우 세션 반환, 없을 경우 null 반환
    HttpSession session = req.getSession(false);

    String value = (String) session.getAttribute(AUTHORIZATION_HEADER); // 가져온 세션에 저장된 Value 를 Name 을 사용하여 가져옵니다.
    System.out.println("value = " + value);

    return "getSession : " + value;
}

세션 생성하는 코드 실행 화면

세션 가져오는 코드 실행 화면

---

JWT란 무엇일까?

JWT(JSON Web Token)는 JSON 포맷을 이용해 사용자에 대한 속성을 저장하는 Claim 기반의 Web Token으로, 즉 토큰의 한 종류임

• 일반적으로 쿠키 저장소를 사용해 JWT를 저장함

JWT 사용 이유

서버가 1대인 상황과 2대 이상인 상황

• 서버가 1대인 경우에는 Session1이 모든 Client의 로그인 정보를 소유하고 있음
• 서버가 2대 이상인 경우(서버의 대용량 트래픽 처리를 위해 서버 2대 이상 운영이 필요할 수 있음),
  • Session 마다 다른 Client 로그인 정보를 가지고 있을 수 있음
    - Session1: Client1, Client2, Client3
    - Session2: Client4
    - Session3: Client5, Client6
  • 로드밸런스는 서버에 랜덤으로 요청을 전달함
  • 그렇기 때문에 만약 Client1의 로그인 정보를 가지고 있지 않은 Server2나 Server3에 API 요청을 하게 되면 문제가 발생할 수 있음

위와 같은 문제의 해결방법

1) Sticky Session: Client마다 요청 Server를 고정시킴

 

2) 세션 저장소 생성해 모든 세션 저장함

세션 저장소 생성: Session Storage가 모든 Client의 로그인 정보 소유하고 있기 때문에 모든 서버에서 모든 Client의 API 요청을 처리할 수 있음

세션 저장소

 

3) JWT 사용

로그인 정보를 Server에 저장하지 않고, Client에 로그인 정보를 JWT로 암호화해 저장 후 JWT 통해 인증/인가

JWT 사용

• 모든 서버에서 동일한 Secret Key 소유함
• Secret Key를 통한 암호화 / 위조 검증(복호화 시)

암호화/위조검증

---

JWT 장/단점

장점

• 동시 접속자가 많을 때 서버 측 부하 낮춤 → 세션 저장소없이 서버 자체에서 검증 가능하기 때문에
• Client, Server가 다른 도메인을 사용할 때 ex) 카카오 OAuth2 로그인 시 JWT Token 사용

단점

• 구현의 복잡도 증가
• JWT에 담는 내용이 커질수록 네트워크 비용 증가함(클라이언트 → 서버)
  
  • JWT 안에 무분별한 정보를 넣는 경우 JWT 길이가 길어지고,
  • 그 JWT가 HTTP 프로토콜에 담겨서 들어올 때, HTTP 프로토콜이 무겁고 용량이 클수록 네트워크 비용이 증가함
• 기 생성된 JWT를 일부만 만료시킬 방법이 없음
  • 쿠키 저장소에 저장된 JWT를 서버에서 만료시킬 방법이 없음
  • 대신, 쿠키 저장소에 저장할 때 쿠키 자체 혹은 JWT 자체에 만료 기한을 줄 수 있음
• Secret Key 유출 시 JWT 조작 가능
  • 그렇기 때문에 JWT에 비밀번호와 같은 민감한 정보 넣으면 안 됨!

---

JWT 사용 흐름

1. Client가 username, password로 로그인 성공 시

 

1-1) 서버에서 "로그인 정보" → JWT로 암호화(Secret Key 사용)

JWT 예시

1-2) 서버에서 직접 쿠키를 생성해 JWT를 담아 Client 응답에 전달

• JWT 전달 방법은 개발자가 정함

// ex) 응답 Header에 아래 형태로 JWT 전달
Cookie cookie = new Cookie(AUTHORIZATION_HEADER, token);
cookie.setPath("/");

// Response 객체에 Cookie 추가
res.addCookie(cookie);

Response 내 Cookie 정보

1-3) 브라우저 쿠키 저장소에 자동으로 JWT 저장됨

 

2. Client에서 JWT 통해 인증하는 방법

 

2-1) 서버에서 API 요청 시마다 쿠키에 포함된 JWT를 찾아서 사용

// 쿠키 찾는 코드
// HttpServletRequest에서 Cookie Value: JWT 가져오기
public String getTokenFromRequest(HttpServletRequest req) {
    Cookie[] cookies = req.getCookies();
    if(cookies != null) {
        for(Cookie cookie : cookies) {
            if(cookie.getName().equals(AUTHORIZATION_HEADER)) {
                try {
                    return URLDecoder.decode(cookie.getValue(), "UTF-8"); // Encode 되어 넘어간 Value 다시 Decode
                }catch (UnsupportedEncodingException e){
                    return null;
                }
            }
        }
    }
    return null;
}

• 쿠키에 담긴 정보가 여러 개일 수 있기 때문에 그 중 이름이 JWT가 담긴 쿠키의 이름과 동일한지 확인해 JWT를 가져옴

2-2) Server에서 검증 확인 절차

• Client가 전달한 JWT 위조 여부 검증(Secret Key 사용)
• JWT 유효기간이 지나지 않았는지 검증
• 검증 성공시, JWT에서 사용자 정보를 가져와 확인

---

JWT 구조

• JWT는 누구나 평문으로 복호화 가능함
• 하지만 Secret Key가 없으면 JWT 수정 불가능함(즉, JWT는 Read Only 데이터임)
• jwt.io

JWT 구조 예시

1. Header

• 어떤 알고리즘 사용했는지 ex) HS256
• 타입 ex) JWT

2. Payload

• 데이터 정보
• JSON 형태로 데이터가 저장되어 있음

3. JWT Signature Verification

• Secret Key를 넣음

---

JWT 다루기

• JWT를 Spring에서 조작하려면, 라이브러리 추가해야 함 → build.gradle 내 dependencies에 아래 코드 추가

// JWT
compileOnly group: 'io.jsonwebtoken', name: 'jjwt-api', version: '0.11.5'
runtimeOnly group: 'io.jsonwebtoken', name: 'jjwt-impl', version: '0.11.5'
runtimeOnly group: 'io.jsonwebtoken', name: 'jjwt-jackson', version: '0.11.5'

• application.properties에 Secret Key 추가

// Base64로 인코딩되어 있는 secret key
jwt.secret.key=7Iqk7YyM66W07YOA7L2U65Sp7YG065+9U3ByaW5n6rCV7J2Y7Yqc7YSw7LWc7JuQ67mI7J6F64uI64ukLg==

JWT Util 클래스 생성

JWT 유틸은 JWT와 관련된 기능들을 가진 클래스

Util(유틸) 클래스
특정한 매개변수 혹은 파라미터에 대한 어떠한 작업을 수행하는 메서드들이 존재하는 클래스
즉, 다른 객체에 의존하지 않고 하나의 모듈로써 동작하는 클래스

ex) 3,000이라고 했을 때 원 혹은 달러를 추가적으로 붙여야하는 문자열 조작하는 유틸 클래스
ex) 날짜를 조작하는 유틸 클래스

 

토큰 생성에 필요한 JWT 데이터

// Header KEY 값
public static final String AUTHORIZATION_HEADER = "Authorization";
// 사용자 권한 값의 KEY
public static final String AUTHORIZATION_KEY = "auth";
// Token 식별자
// 토큰 앞에 붙일 규칙
public static final String BEARER_PREFIX = "Bearer ";
// 토큰 만료시간
private final long TOKEN_TIME = 60 * 60 * 1000L; // 60분

@Value("${jwt.secret.key}") // Base64 Encode 한 SecretKey
private String secretKey;
private Key key;
private final SignatureAlgorithm signatureAlgorithm = SignatureAlgorithm.HS256;

// 로깅: 애플리케이션이 동작을 하는 동안에 프로젝트의 상태나 어떠한 동작 정보를 시간 순으로 입력하는 것
public static final Logger logger = LoggerFactory.getLogger("JWT 관련 로그");

// @PostConstruct는 딱 한 번만 받아 오면 되는 값을 사용할 때마다 요청을 새로 호출하는 실수를 방지하기 위해 사용
@PostConstruct
public void init() {
    byte[] bytes = Base64.getDecoder().decode(secretKey);
    key = Keys.hmacShaKeyFor(bytes);
}

 

사용자 권한을 관리하는 Enum Class 생성

package com.sparta.springauth.entity;

public enum UserRoleEnum {
    USER(Authority.USER),  // 사용자 권한
    ADMIN(Authority.ADMIN);  // 관리자 권한

    private final String authority;

    UserRoleEnum(String authority) {
        this.authority = authority;
    }

    public String getAuthority() {
        return this.authority;
    }

    public static class Authority {
        public static final String USER = "ROLE_USER";
        public static final String ADMIN = "ROLE_ADMIN";
    }
}

 

JWT 생성

[JWT 생성 후 반환하는 방법 2가지]
1. Response Header에 JWT 토큰 달아서 응답

• Cookie 생각보다 코드가 간결함

2. Cookie 객체 생성 후 Cookie 객체에 Token을 담은 후, 그 Cookie를 Response 객체에 담아서 응답

• JWT 토큰 만료 기한 뿐만 아니라 쿠키에 대한 만료 기한을 줄 수 있음
• 다른 옵션도 추가할 수 있음
• 또한, 서버에서 Cookie를 만들고 Header에 Set-Cookie라는 이름으로 넘어가면 자동으로 Cookie가 저장됨

// 토큰 생성
public String createToken(String username, UserRoleEnum role) {
    Date date = new Date();

    return BEARER_PREFIX +
            Jwts.builder()
                    .setSubject(username) // 사용자 식별자값(ID)
                    .claim(AUTHORIZATION_KEY, role) // 사용자 권한(key-value)
                    .setExpiration(new Date(date.getTime() + TOKEN_TIME)) // 만료 시간
                    .setIssuedAt(date) // 발급일
                    .signWith(key, signatureAlgorithm) // 암호화 알고리즘(secret Key, 선택한 알고리즘)
                    .compact();
}

 

생성된 JWT를 Cookie에 저장

// -------- 생성된 JWT를 Cookie에 저장 --------
public void addJwtToCookie(String token, HttpServletResponse res) {
    try {
        token = URLEncoder.encode(token, "utf-8").replaceAll("\\+", "%20"); // Cookie Value 에는 공백이 불가능해서 encoding 진행

        Cookie cookie = new Cookie(AUTHORIZATION_HEADER, token); // Name-Value
        cookie.setPath("/");

        // Response 객체에 Cookie 추가
        res.addCookie(cookie);
    } catch (UnsupportedEncodingException e) {
        logger.error(e.getMessage());
    }
}

 

Cookie에 들어있는 JWT 토큰 Substring

• 앞에 붙인 Bearer를 떼기 위해 Substring 수행함

// JWT 토큰 substring
public String substringToken(String tokenValue) {
    if (StringUtils.hasText(tokenValue) && tokenValue.startsWith(BEARER_PREFIX)) {
        return tokenValue.substring(7);
    }
    logger.error("Not Found Token");
    throw new NullPointerException("Not Found Token");
}

 

JWT 검증

// 토큰 검증
public boolean validateToken(String token) {
    try {
        Jwts.parserBuilder().setSigningKey(key).build().parseClaimsJws(token);
        return true;
    } catch (SecurityException | MalformedJwtException | SignatureException e) {
        logger.error("Invalid JWT signature, 유효하지 않는 JWT 서명 입니다.");
    } catch (ExpiredJwtException e) {
        logger.error("Expired JWT token, 만료된 JWT token 입니다.");
    } catch (UnsupportedJwtException e) {
        logger.error("Unsupported JWT token, 지원되지 않는 JWT 토큰 입니다.");
    } catch (IllegalArgumentException e) {
        logger.error("JWT claims is empty, 잘못된 JWT 토큰 입니다.");
    }
    return false;
}

 

JWT에서 사용자 정보 가져오기

// 토큰에서 사용자 정보 가져오기
public Claims getUserInfoFromToken(String token) {
    return Jwts.parserBuilder().setSigningKey(key).build().parseClaimsJws(token).getBody();
}

JWT 검증하기

package com.sparta.springauth.auth;

import com.sparta.springauth.entity.UserRoleEnum;
import com.sparta.springauth.jwt.JwtUtil;
import io.jsonwebtoken.Claims;
import jakarta.servlet.http.Cookie;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import jakarta.servlet.http.HttpSession;
import org.springframework.web.bind.annotation.CookieValue;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.io.UnsupportedEncodingException;
import java.net.URLDecoder;
import java.net.URLEncoder;

@RestController
@RequestMapping("/api")
public class AuthController {
	...
    
    private final JwtUtil jwtUtil;

    public AuthController(JwtUtil jwtUtil){
        this.jwtUtil = jwtUtil;
    }

    ...

    @GetMapping("/create-jwt")
    public String createJwt(HttpServletResponse res) {
        // Jwt 생성
        String token = jwtUtil.createToken("Robbie", UserRoleEnum.USER);

        // Jwt 쿠키 저장
        jwtUtil.addJwtToCookie(token, res);

        return "createJwt : " + token;
    }

    @GetMapping("/get-jwt")
    public String getJwt(@CookieValue(JwtUtil.AUTHORIZATION_HEADER) String tokenValue) {
        // JWT 토큰 substring
        String token = jwtUtil.substringToken(tokenValue);

        // 토큰 검증
        if(!jwtUtil.validateToken(token)){
            throw new IllegalArgumentException("Token Error");
        }

        // 토큰에서 사용자 정보 가져오기
        Claims info = jwtUtil.getUserInfoFromToken(token);
        // 사용자 username
        String username = info.getSubject();
        System.out.println("username = " + username);
        // 사용자 권한
        String authority = (String) info.get(JwtUtil.AUTHORIZATION_KEY);
        System.out.println("authority = " + authority);

        return "getJwt : " + username + ", " + authority;
    }

    ...
}

JWT 생성 코드 결과

JWT 조회 코드 결과